@webmaster-droid/server 0.1.0-alpha.0

package/dist/chunk-MLID7STX.js

@@ -0,0 +1,412 @@
+// src/storage-s3/index.ts
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  ListObjectsV2Command,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
+import { normalizeCmsDocument } from "@webmaster-droid/contracts";
+function createId(prefix) {
+  return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function monthKey(date = /* @__PURE__ */ new Date()) {
+  const year = date.getUTCFullYear();
+  const month = `${date.getUTCMonth() + 1}`.padStart(2, "0");
+  return `${year}-${month}`;
+}
+function keySafeTimestamp(date = /* @__PURE__ */ new Date()) {
+  return `${date.getTime()}`;
+}
+async function bodyToString(body) {
+  if (!body) {
+    return "";
+  }
+  if (typeof body === "string") {
+    return body;
+  }
+  if (typeof body === "object" && body !== null && "transformToString" in body && typeof body.transformToString === "function") {
+    return body.transformToString();
+  }
+  return "";
+}
+function parseIdFromKey(key) {
+  const filename = key.split("/").pop() ?? key;
+  const parts = filename.split("__");
+  if (parts.length !== 2) {
+    return filename.replace(/\.json$/, "");
+  }
+  return parts[1].replace(/\.json$/, "");
+}
+function parseTimestampFromKey(key) {
+  const filename = key.split("/").pop() ?? key;
+  const parts = filename.split("__");
+  if (parts.length !== 2) {
+    return (/* @__PURE__ */ new Date(0)).toISOString();
+  }
+  const encoded = Number(parts[0]);
+  const parsed = new Date(encoded);
+  if (Number.isNaN(parsed.getTime())) {
+    return (/* @__PURE__ */ new Date(0)).toISOString();
+  }
+  return parsed.toISOString();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseCheckpointEnvelope(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const checkpoint = value.checkpoint;
+  const content = value.content;
+  if (!isRecord(checkpoint) || !isRecord(content)) {
+    return null;
+  }
+  const id = typeof checkpoint.id === "string" ? checkpoint.id : "";
+  const createdAt = typeof checkpoint.createdAt === "string" ? checkpoint.createdAt : "";
+  const reason = typeof checkpoint.reason === "string" ? checkpoint.reason : "";
+  const createdBy = typeof checkpoint.createdBy === "string" ? checkpoint.createdBy : void 0;
+  if (!id || !createdAt || !reason) {
+    return null;
+  }
+  return {
+    checkpoint: {
+      id,
+      createdAt,
+      createdBy,
+      reason
+    },
+    content
+  };
+}
+function mergeLegacyValue(target, incoming) {
+  if (!isRecord(target) || !isRecord(incoming)) {
+    return incoming;
+  }
+  for (const [key, value] of Object.entries(incoming)) {
+    if (target[key] === void 0) {
+      target[key] = value;
+      continue;
+    }
+    target[key] = mergeLegacyValue(target[key], value);
+  }
+  return target;
+}
+function normalizeLegacyIndexedKeys(root) {
+  let changed = false;
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        visit(item);
+      }
+      return;
+    }
+    if (!isRecord(node)) {
+      return;
+    }
+    const record = node;
+    const keys = Object.keys(record);
+    for (const key of keys) {
+      const match = /^([^\[\]]+)\[(\d+)\]$/.exec(key);
+      if (!match) {
+        continue;
+      }
+      const baseKey = match[1];
+      const index = Number(match[2]);
+      if (Number.isNaN(index)) {
+        continue;
+      }
+      const baseValue = record[baseKey];
+      if (baseValue !== void 0 && !Array.isArray(baseValue)) {
+        continue;
+      }
+      const targetArray = record[baseKey] ?? [];
+      record[baseKey] = targetArray;
+      const legacyValue = record[key];
+      const existing = targetArray[index];
+      if (existing === void 0) {
+        targetArray[index] = legacyValue;
+      } else {
+        targetArray[index] = mergeLegacyValue(existing, legacyValue);
+      }
+      delete record[key];
+      changed = true;
+    }
+    for (const value of Object.values(record)) {
+      visit(value);
+    }
+  };
+  visit(root);
+  return changed;
+}
+var S3CmsStorage = class {
+  bucket;
+  client;
+  prefix;
+  constructor(options) {
+    this.bucket = options.bucket;
+    this.prefix = options.prefix?.replace(/\/$/, "") ?? "cms";
+    this.client = options.client ?? new S3Client({
+      region: options.region
+    });
+  }
+  async ensureInitialized(seed) {
+    const [live, draft] = await Promise.all([
+      this.tryGetStage("live"),
+      this.tryGetStage("draft")
+    ]);
+    if (!live) {
+      await this.saveStage("live", seed);
+    }
+    if (!draft) {
+      await this.saveStage("draft", seed);
+    }
+  }
+  async getContent(stage) {
+    const key = this.stageKey(stage);
+    const response = await this.client.send(
+      new GetObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      })
+    );
+    const text = await bodyToString(response.Body);
+    const parsed = JSON.parse(text);
+    normalizeLegacyIndexedKeys(parsed);
+    return normalizeCmsDocument(parsed);
+  }
+  async saveDraft(content) {
+    await this.saveStage("draft", content);
+  }
+  async saveLive(content) {
+    await this.saveStage("live", content);
+  }
+  async putPublicAsset(input) {
+    const key = input.key.replace(/^\/+/, "");
+    if (!key) {
+      throw new Error("Public asset key is required.");
+    }
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: input.body,
+        ContentType: input.contentType,
+        CacheControl: input.cacheControl
+      })
+    );
+  }
+  async createCheckpoint(content, input) {
+    const createdAt = nowIso();
+    const id = createId("cp");
+    const key = `${this.prefix}/checkpoints/${keySafeTimestamp()}__${id}.json`;
+    const checkpointMeta = {
+      id,
+      createdAt,
+      createdBy: input.createdBy,
+      reason: input.reason
+    };
+    const payload = {
+      checkpoint: checkpointMeta,
+      content: {
+        ...content,
+        meta: {
+          ...content.meta,
+          updatedAt: createdAt,
+          updatedBy: input.createdBy,
+          sourceCheckpointId: id
+        }
+      }
+    };
+    await this.putJson(key, payload);
+    return checkpointMeta;
+  }
+  async deleteCheckpoint(id) {
+    const targetId = id.trim();
+    if (!targetId) {
+      return false;
+    }
+    const keys = await this.listKeys(`${this.prefix}/checkpoints/`);
+    const key = keys.find((candidate) => parseIdFromKey(candidate) === targetId);
+    if (!key) {
+      return false;
+    }
+    await this.client.send(
+      new DeleteObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      })
+    );
+    return true;
+  }
+  async listCheckpoints() {
+    const keys = await this.listKeys(`${this.prefix}/checkpoints/`);
+    const items = await Promise.all(
+      keys.map(async (key) => {
+        const fallback = {
+          id: parseIdFromKey(key),
+          createdAt: parseTimestampFromKey(key),
+          reason: "auto-checkpoint"
+        };
+        try {
+          const text = await this.getText(key);
+          const parsed = JSON.parse(text);
+          const envelope = parseCheckpointEnvelope(parsed);
+          if (!envelope) {
+            return fallback;
+          }
+          return {
+            id: envelope.checkpoint.id || fallback.id,
+            createdAt: envelope.checkpoint.createdAt || fallback.createdAt,
+            createdBy: envelope.checkpoint.createdBy,
+            reason: envelope.checkpoint.reason || fallback.reason
+          };
+        } catch {
+          return fallback;
+        }
+      })
+    );
+    return items.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  }
+  async publishDraft(input) {
+    const createdAt = nowIso();
+    const id = createId("pub");
+    const key = `${this.prefix}/published/${keySafeTimestamp()}__${id}.json`;
+    const payload = {
+      ...input.content,
+      meta: {
+        ...input.content.meta,
+        updatedAt: createdAt,
+        updatedBy: input.createdBy,
+        contentVersion: id
+      }
+    };
+    await this.putJson(key, payload);
+    return {
+      id,
+      createdAt,
+      createdBy: input.createdBy,
+      sourceContentVersion: input.content.meta.contentVersion
+    };
+  }
+  async listPublishedVersions() {
+    const keys = await this.listKeys(`${this.prefix}/published/`);
+    const items = keys.map((key) => {
+      const id = parseIdFromKey(key);
+      const createdAt = parseTimestampFromKey(key);
+      return {
+        id,
+        createdAt,
+        sourceContentVersion: id
+      };
+    });
+    return items.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  }
+  async getSnapshot(input) {
+    const folder = input.sourceType === "checkpoint" ? `${this.prefix}/checkpoints/` : `${this.prefix}/published/`;
+    const keys = await this.listKeys(folder);
+    const key = keys.find((candidate) => parseIdFromKey(candidate) === input.sourceId);
+    if (!key) {
+      return null;
+    }
+    const response = await this.client.send(
+      new GetObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      })
+    );
+    const text = await bodyToString(response.Body);
+    const parsed = JSON.parse(text);
+    const envelope = parseCheckpointEnvelope(parsed);
+    const content = envelope ? envelope.content : parsed;
+    normalizeLegacyIndexedKeys(content);
+    return normalizeCmsDocument(content);
+  }
+  async appendEvent(event) {
+    const key = `${this.prefix}/events/${monthKey()}.jsonl`;
+    const existing = await this.tryGetText(key);
+    const line = `${JSON.stringify(event)}
+`;
+    const body = `${existing ?? ""}${line}`;
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: body,
+        ContentType: "application/x-ndjson"
+      })
+    );
+  }
+  async tryGetStage(stage) {
+    try {
+      return await this.getContent(stage);
+    } catch (error) {
+      if (this.isMissingKey(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async saveStage(stage, content) {
+    await this.putJson(this.stageKey(stage), content);
+  }
+  stageKey(stage) {
+    return `${this.prefix}/${stage}/current.json`;
+  }
+  async putJson(key, value) {
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: JSON.stringify(value, null, 2),
+        ContentType: "application/json"
+      })
+    );
+  }
+  async listKeys(prefix) {
+    const response = await this.client.send(
+      new ListObjectsV2Command({
+        Bucket: this.bucket,
+        Prefix: prefix
+      })
+    );
+    const keys = (response.Contents ?? []).map((item) => item.Key).filter((key) => Boolean(key));
+    return keys;
+  }
+  async tryGetText(key) {
+    try {
+      return await this.getText(key);
+    } catch (error) {
+      if (this.isMissingKey(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getText(key) {
+    const response = await this.client.send(
+      new GetObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      })
+    );
+    return bodyToString(response.Body);
+  }
+  isMissingKey(error) {
+    if (typeof error === "object" && error !== null && "name" in error && error.name === "NoSuchKey") {
+      return true;
+    }
+    if (typeof error === "object" && error !== null && "$metadata" in error && typeof error.$metadata?.httpStatusCode === "number") {
+      return error.$metadata?.httpStatusCode === 404;
+    }
+    return false;
+  }
+};
+
+export {
+  S3CmsStorage
+};