dynamo-provider.ts

import { readFileSync } from "node:fs";

import { createGenericHandler } from "../core/createGenericHandler.js";
import { resolveTagCache } from "../core/resolve.js";

const PHYSICAL_RESOURCE_ID = "dynamodb-cache" as const;

//TODO: modify this, we should use the same format as the cache
type DataType = {
  tag: {
    S: string;
  };
  path: {
    S: string;
  };
  revalidatedAt: {
    N: string;
  };
  /**
   * The time at which the tag should be considered stale, in milliseconds since epoch.
   */
  stale?: {
    N: string;
  };
  /**
   * The time at which the tag should expire, in milliseconds since epoch.
   */
  expire?: {
    N: string;
  };
};

export interface InitializationFunctionEvent {
  type: "initializationFunction";
  requestType: "create" | "update" | "delete";
  resourceId: typeof PHYSICAL_RESOURCE_ID;
}

const tagCache = await resolveTagCache(
  globalThis.openNextConfig?.initializationFunction?.tagCache,
);

export const handler = await createGenericHandler({
  handler: defaultHandler,
  type: "initializationFunction",
});

async function defaultHandler(
  event: InitializationFunctionEvent,
): Promise<InitializationFunctionEvent> {
  switch (event.requestType) {
    case "delete":
      return remove();
    default:
      return insert(event.requestType);
  }
}

async function insert(
  requestType: InitializationFunctionEvent["requestType"],
): Promise<InitializationFunctionEvent> {
  // If it is in nextMode, we don't need to do anything
  if (tagCache.mode === "nextMode") {
    return {
      type: "initializationFunction",
      requestType,
      resourceId: PHYSICAL_RESOURCE_ID,
    };
  }
  const file = readFileSync("dynamodb-cache.json", "utf8");

  const data: DataType[] = JSON.parse(file);

  const parsedData = data.map((item) => ({
    tag: item.tag.S,
    path: item.path.S,
    revalidatedAt: Number.parseInt(item.revalidatedAt.N),
    ...(item.stale && { stale: Number.parseInt(item.stale.N) }),
    ...(item.expire && { expire: Number.parseInt(item.expire.N) }),
  }));

  await tagCache.writeTags(parsedData);

  return {
    type: "initializationFunction",
    requestType,
    resourceId: PHYSICAL_RESOURCE_ID,
  };
}

async function remove(): Promise<InitializationFunctionEvent> {
  // Do we want to actually delete anything here?
  return {
    type: "initializationFunction",
    requestType: "delete",
    resourceId: PHYSICAL_RESOURCE_ID,
  };
}