@cancia/astro 0.0.1

package/dist/chunk-YQDZQSES.js

@@ -0,0 +1,393 @@
+import {
+  RevConflictError
+} from "./chunk-7IA5B5CF.js";
+
+// src/loader/index.ts
+import { join as join2 } from "path";
+
+// src/storage/json-file-v2.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, rmSync } from "fs";
+import { dirname as dirname2, join } from "path";
+import { createHash, randomUUID } from "crypto";
+
+// src/storage/json-file.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+function readStore(filePath) {
+  if (!existsSync(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeStore(filePath, data) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+function createJsonFileAdapter(filePath) {
+  const path = filePath ?? process.cwd() + "/cancia-content.json";
+  return {
+    async get(site, key, lang) {
+      const store = readStore(path);
+      return store[`${site}::${key}.${lang}`] ?? null;
+    },
+    async set(site, key, lang, value) {
+      const store = readStore(path);
+      store[`${site}::${key}.${lang}`] = value;
+      writeStore(path, store);
+    },
+    async getAll(site) {
+      const store = readStore(path);
+      const prefix = `${site}::`;
+      const result = {};
+      for (const [k, v] of Object.entries(store)) {
+        if (k.startsWith(prefix)) {
+          result[k.slice(prefix.length)] = v;
+        }
+      }
+      return result;
+    },
+    async delete(site, key, lang) {
+      const store = readStore(path);
+      delete store[`${site}::${key}.${lang}`];
+      writeStore(path, store);
+    }
+  };
+}
+
+// src/storage/json-file-v2.ts
+function canonicalize(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalize).join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalize(obj[k])}`).join(",")}}`;
+}
+function hashRev(value) {
+  return createHash("sha256").update(canonicalize(value)).digest("hex").slice(0, 16);
+}
+function readJsonFile(filePath, fallback) {
+  if (!existsSync2(filePath)) return fallback;
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJsonFile(filePath, data) {
+  mkdirSync2(dirname2(filePath), { recursive: true });
+  writeFileSync2(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+function pageKey(site, route) {
+  return `${site}::${route}`;
+}
+function makePageStore(pagesPath) {
+  return {
+    async get(site, route) {
+      const all = readJsonFile(pagesPath, {});
+      const meta = all[pageKey(site, route)];
+      if (!meta) return null;
+      return { route, meta, _rev: hashRev(meta) };
+    },
+    async list(site) {
+      const all = readJsonFile(pagesPath, {});
+      const prefix = `${site}::`;
+      const records = [];
+      for (const [k, meta] of Object.entries(all)) {
+        if (!k.startsWith(prefix)) continue;
+        records.push({
+          route: k.slice(prefix.length),
+          meta,
+          _rev: hashRev(meta)
+        });
+      }
+      return records;
+    },
+    async set(site, route, meta, rev) {
+      const all = readJsonFile(pagesPath, {});
+      const key = pageKey(site, route);
+      const existing = all[key];
+      if (existing) {
+        const currentRev = hashRev(existing);
+        if (rev !== currentRev) throw new RevConflictError();
+      }
+      all[key] = meta;
+      writeJsonFile(pagesPath, all);
+      return { route, meta, _rev: hashRev(meta) };
+    },
+    async delete(site, route) {
+      const all = readJsonFile(pagesPath, {});
+      delete all[pageKey(site, route)];
+      writeJsonFile(pagesPath, all);
+    }
+  };
+}
+var RESERVED_DIRS = /* @__PURE__ */ new Set(["_order.json"]);
+function listSiteDir(listsDir, listName, site) {
+  return join(listsDir, listName, site);
+}
+function localeDir(listsDir, listName, site, locale) {
+  return join(listSiteDir(listsDir, listName, site), locale);
+}
+function entryPath(listsDir, listName, site, locale, id) {
+  return join(localeDir(listsDir, listName, site, locale), `${id}.json`);
+}
+function orderPath(listsDir, listName, site) {
+  return join(listSiteDir(listsDir, listName, site), "_order.json");
+}
+function toEntry(raw) {
+  return { ...raw, _rev: hashRev(raw.data) };
+}
+function readOrder(listsDir, listName, site) {
+  return readJsonFile(orderPath(listsDir, listName, site), { ids: [] }).ids;
+}
+function writeOrder(listsDir, listName, site, ids) {
+  writeJsonFile(orderPath(listsDir, listName, site), { ids });
+}
+function listLocales(listsDir, listName, site) {
+  const siteDir = listSiteDir(listsDir, listName, site);
+  if (!existsSync2(siteDir)) return [];
+  return readdirSync(siteDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !RESERVED_DIRS.has(d.name)).map((d) => d.name);
+}
+function listEntryIdsInLocale(listsDir, listName, site, locale) {
+  const dir = localeDir(listsDir, listName, site, locale);
+  if (!existsSync2(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+}
+function makeListStore(listsDir) {
+  function readEntry(site, listName, id, locale) {
+    const path = entryPath(listsDir, listName, site, locale, id);
+    if (!existsSync2(path)) return null;
+    try {
+      return JSON.parse(readFileSync2(path, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  function writeEntry(site, listName, locale, entry) {
+    writeJsonFile(entryPath(listsDir, listName, site, locale, entry.id), entry);
+  }
+  function applyOrder(order, ids) {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const id of order) {
+      if (ids.has(id)) {
+        result.push(id);
+        seen.add(id);
+      }
+    }
+    const extras = [...ids].filter((id) => !seen.has(id)).sort();
+    return [...result, ...extras];
+  }
+  return {
+    async list(site, listName, locale) {
+      const order = readOrder(listsDir, listName, site);
+      if (locale !== void 0) {
+        const ids = new Set(listEntryIdsInLocale(listsDir, listName, site, locale));
+        const sorted = applyOrder(order, ids);
+        const entries2 = [];
+        for (const id of sorted) {
+          const raw = readEntry(site, listName, id, locale);
+          if (raw) entries2.push(toEntry(raw));
+        }
+        return entries2;
+      }
+      const locales = listLocales(listsDir, listName, site);
+      const allIds = /* @__PURE__ */ new Set();
+      for (const loc of locales) {
+        for (const id of listEntryIdsInLocale(listsDir, listName, site, loc)) {
+          allIds.add(id);
+        }
+      }
+      const sortedIds = applyOrder(order, allIds);
+      const entries = [];
+      for (const id of sortedIds) {
+        for (const loc of locales) {
+          const raw = readEntry(site, listName, id, loc);
+          if (raw) entries.push(toEntry(raw));
+        }
+      }
+      return entries;
+    },
+    async get(site, listName, id, locale) {
+      const raw = readEntry(site, listName, id, locale);
+      return raw ? toEntry(raw) : null;
+    },
+    async create(site, listName, data, locale, id) {
+      const finalId = id ?? randomUUID();
+      const existing = readEntry(site, listName, finalId, locale);
+      if (existing) {
+        throw new Error(`List entry "${finalId}" already exists in "${listName}" (${locale})`);
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const entry = {
+        id: finalId,
+        locale,
+        data,
+        createdAt: now,
+        updatedAt: now
+      };
+      writeEntry(site, listName, locale, entry);
+      const order = readOrder(listsDir, listName, site);
+      if (!order.includes(finalId)) {
+        writeOrder(listsDir, listName, site, [...order, finalId]);
+      }
+      return toEntry(entry);
+    },
+    async update(site, listName, id, locale, data, rev) {
+      const existing = readEntry(site, listName, id, locale);
+      if (!existing) {
+        throw new Error(`List entry "${id}" not found in "${listName}" (${locale})`);
+      }
+      if (hashRev(existing.data) !== rev) throw new RevConflictError();
+      const updated = {
+        ...existing,
+        data,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      writeEntry(site, listName, locale, updated);
+      return toEntry(updated);
+    },
+    async delete(site, listName, id, locale) {
+      const path = entryPath(listsDir, listName, site, locale, id);
+      if (!existsSync2(path)) return;
+      rmSync(path);
+      const stillExists = listLocales(listsDir, listName, site).some((loc) => existsSync2(entryPath(listsDir, listName, site, loc, id)));
+      if (!stillExists) {
+        const order = readOrder(listsDir, listName, site);
+        const next = order.filter((existingId) => existingId !== id);
+        if (next.length !== order.length) {
+          writeOrder(listsDir, listName, site, next);
+        }
+      }
+    },
+    async reorder(site, listName, ids) {
+      const locales = listLocales(listsDir, listName, site);
+      const allIds = /* @__PURE__ */ new Set();
+      for (const loc of locales) {
+        for (const id of listEntryIdsInLocale(listsDir, listName, site, loc)) {
+          allIds.add(id);
+        }
+      }
+      for (const id of ids) {
+        if (!allIds.has(id)) {
+          throw new Error(`Cannot reorder: entry "${id}" not found in "${listName}"`);
+        }
+      }
+      const supplied = new Set(ids);
+      for (const id of allIds) {
+        if (supplied.has(id)) continue;
+        for (const loc of locales) {
+          const path = entryPath(listsDir, listName, site, loc, id);
+          if (existsSync2(path)) rmSync(path);
+        }
+      }
+      writeOrder(listsDir, listName, site, ids);
+    },
+    async translations(site, listName) {
+      const locales = listLocales(listsDir, listName, site);
+      const idToLocales = /* @__PURE__ */ new Map();
+      for (const loc of locales) {
+        for (const id of listEntryIdsInLocale(listsDir, listName, site, loc)) {
+          const existing = idToLocales.get(id) ?? [];
+          existing.push(loc);
+          idToLocales.set(id, existing);
+        }
+      }
+      const order = readOrder(listsDir, listName, site);
+      const orderedIds = applyOrder(order, new Set(idToLocales.keys()));
+      return orderedIds.map((id) => ({
+        id,
+        locales: idToLocales.get(id) ?? []
+      }));
+    }
+  };
+}
+function createJsonFileAdapterV2(opts = {}) {
+  const root = opts.projectRoot ?? process.cwd();
+  const kvPath = opts.kvPath ?? join(root, "cancia-content.json");
+  const pagesPath = opts.pagesPath ?? join(root, ".cancia", "pages.json");
+  const listsDir = opts.listsDir ?? join(root, ".cancia", "lists");
+  return {
+    kv: createJsonFileAdapter(kvPath),
+    pages: makePageStore(pagesPath),
+    lists: makeListStore(listsDir)
+  };
+}
+
+// src/loader/index.ts
+function makeId(locale, entryId) {
+  return `${locale}/${entryId}`;
+}
+async function syncOnce(ctx, lists, list, site) {
+  ctx.store.clear();
+  const entries = await lists.list(site, list);
+  for (const entry of entries) {
+    const id = makeId(entry.locale, entry.id);
+    const data = {
+      ...entry.data,
+      locale: entry.locale,
+      createdAt: entry.createdAt,
+      updatedAt: entry.updatedAt
+    };
+    ctx.store.set({
+      id,
+      data,
+      digest: entry._rev
+    });
+  }
+  ctx.logger.info(
+    `cancia: loaded ${entries.length} entr${entries.length === 1 ? "y" : "ies"} from list "${list}"`
+  );
+}
+function canciaLoader(opts) {
+  let watcherAttached = false;
+  let latestCtx = null;
+  let pendingTimer = null;
+  let inflight = Promise.resolve();
+  return {
+    name: `@cancia/astro/loader[${opts.list}]`,
+    async load(ctx) {
+      latestCtx = ctx;
+      const storage = opts.storage ?? createJsonFileAdapterV2({
+        projectRoot: opts.projectRoot ?? process.cwd()
+      });
+      const { lists } = storage;
+      await syncOnce(ctx, lists, opts.list, opts.site);
+      if (ctx.watcher && !watcherAttached) {
+        watcherAttached = true;
+        const root = opts.projectRoot ?? process.cwd();
+        const watchDir = join2(root, ".cancia", "lists", opts.list, opts.site);
+        ctx.watcher.add(watchDir);
+        const scheduleSync = () => {
+          if (pendingTimer) clearTimeout(pendingTimer);
+          pendingTimer = setTimeout(() => {
+            pendingTimer = null;
+            inflight = inflight.catch(() => {
+            }).then(
+              () => syncOnce(latestCtx, lists, opts.list, opts.site).catch((err) => {
+                latestCtx.logger.error(`cancia: resync failed \u2014 ${err.message}`);
+              })
+            );
+          }, 50);
+        };
+        const onEvent = (path) => {
+          if (!path.startsWith(watchDir)) return;
+          scheduleSync();
+        };
+        ctx.watcher.on("change", onEvent);
+        ctx.watcher.on("add", onEvent);
+        ctx.watcher.on("unlink", onEvent);
+      }
+    }
+  };
+}
+
+export {
+  createJsonFileAdapter,
+  createJsonFileAdapterV2,
+  canciaLoader
+};

package/dist/endpoints/auth.d.ts

@@ -0,0 +1,5 @@
+declare function POST({ request }: {
+    request: Request;
+}): Promise<Response>;
+
+export { POST };

package/dist/endpoints/auth.js

@@ -0,0 +1,56 @@
+// src/endpoints/auth.ts
+import { getCanciaRuntime } from "virtual:cancia/runtime";
+var buckets = /* @__PURE__ */ new Map();
+var MAX_FAILURES = 5;
+var WINDOW_MS = 6e4;
+function getIp(req) {
+  return req.headers.get("x-forwarded-for")?.split(",")[0].trim() ?? req.headers.get("x-real-ip") ?? "unknown";
+}
+function isRateLimited(ip) {
+  const bucket = buckets.get(ip);
+  if (!bucket || Date.now() > bucket.resetAt) return false;
+  return bucket.failures >= MAX_FAILURES;
+}
+function recordFailure(ip) {
+  const now = Date.now();
+  const bucket = buckets.get(ip);
+  if (!bucket || now > bucket.resetAt) {
+    buckets.set(ip, { failures: 1, resetAt: now + WINDOW_MS });
+  } else {
+    bucket.failures += 1;
+  }
+}
+async function POST({ request }) {
+  const { secret } = getCanciaRuntime();
+  const ip = getIp(request);
+  if (isRateLimited(ip))
+    return new Response(
+      JSON.stringify({ error: "Too many attempts. Try again in a minute." }),
+      { status: 429, headers: { "Content-Type": "application/json" } }
+    );
+  let token;
+  try {
+    const body = await request.json();
+    token = body?.token;
+  } catch {
+    return new Response(
+      JSON.stringify({ error: "Invalid request body" }),
+      { status: 400, headers: { "Content-Type": "application/json" } }
+    );
+  }
+  if (!token || token !== secret) {
+    recordFailure(ip);
+    return new Response(
+      JSON.stringify({ error: "Invalid token" }),
+      { status: 401, headers: { "Content-Type": "application/json" } }
+    );
+  }
+  buckets.delete(ip);
+  return new Response(
+    JSON.stringify({ ok: true }),
+    { status: 200, headers: { "Content-Type": "application/json" } }
+  );
+}
+export {
+  POST
+};

package/dist/endpoints/content.d.ts

@@ -0,0 +1,11 @@
+declare function GET({ request }: {
+    request: Request;
+}): Promise<Response>;
+declare function POST({ request }: {
+    request: Request;
+}): Promise<Response>;
+declare function DELETE({ request }: {
+    request: Request;
+}): Promise<Response>;
+
+export { DELETE, GET, POST };

package/dist/endpoints/content.js

@@ -0,0 +1,56 @@
+// src/endpoints/content.ts
+import { getCanciaRuntime } from "virtual:cancia/runtime";
+function checkAuth(req, secret) {
+  if (!secret) return null;
+  const token = req.headers.get("Authorization")?.replace("Bearer ", "").trim();
+  if (token !== secret)
+    return new Response(JSON.stringify({ error: "Unauthorized" }), { status: 401 });
+  return null;
+}
+async function GET({ request }) {
+  const { storage, secret } = getCanciaRuntime();
+  const deny = checkAuth(request, secret);
+  if (deny) return deny;
+  const site = new URL(request.url).searchParams.get("site");
+  if (!site)
+    return new Response(JSON.stringify({ error: "Missing ?site=" }), { status: 400 });
+  const data = await storage.getAll(site);
+  return new Response(JSON.stringify(data), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
+async function POST({ request }) {
+  const { storage, secret } = getCanciaRuntime();
+  const deny = checkAuth(request, secret);
+  if (deny) return deny;
+  const body = await request.json().catch(() => null);
+  if (!body?.site || !body?.key || !body?.lang || body?.value === void 0)
+    return new Response(
+      JSON.stringify({ error: "Missing fields: site, key, lang, value" }),
+      { status: 400 }
+    );
+  await storage.set(body.site, body.key, body.lang, body.value);
+  return new Response(JSON.stringify({ ok: true }), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
+async function DELETE({ request }) {
+  const { storage, secret } = getCanciaRuntime();
+  const deny = checkAuth(request, secret);
+  if (deny) return deny;
+  const body = await request.json().catch(() => null);
+  if (!body?.site || !body?.key || !body?.lang)
+    return new Response(
+      JSON.stringify({ error: "Missing fields: site, key, lang" }),
+      { status: 400 }
+    );
+  await storage.delete(body.site, body.key, body.lang);
+  return new Response(JSON.stringify({ ok: true }), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export {
+  DELETE,
+  GET,
+  POST
+};

package/dist/endpoints/health.d.ts

@@ -0,0 +1,3 @@
+declare function GET(): Response;
+
+export { GET };

package/dist/endpoints/health.js

@@ -0,0 +1,9 @@
+// src/endpoints/health.ts
+function GET() {
+  return new Response(JSON.stringify({ ok: true }), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export {
+  GET
+};

package/dist/endpoints/lists.d.ts

@@ -0,0 +1,14 @@
+declare function GET({ request }: {
+    request: Request;
+}): Promise<Response>;
+declare function POST({ request }: {
+    request: Request;
+}): Promise<Response>;
+declare function PATCH({ request }: {
+    request: Request;
+}): Promise<Response>;
+declare function DELETE({ request }: {
+    request: Request;
+}): Promise<Response>;
+
+export { DELETE, GET, PATCH, POST };

package/dist/endpoints/lists.js

@@ -0,0 +1,36 @@
+import {
+  makeListsRoutes
+} from "../chunk-22DJVJBR.js";
+import "../chunk-NG5GJME5.js";
+import "../chunk-7IA5B5CF.js";
+
+// src/endpoints/lists.ts
+import { getCanciaRuntime } from "virtual:cancia/runtime";
+function getRoutes() {
+  const rt = getCanciaRuntime();
+  return makeListsRoutes({
+    storageV2: rt.storageV2,
+    projectRoot: rt.projectRoot,
+    schemasPath: rt.schemasPath,
+    secret: rt.secret,
+    defaultLocale: rt.defaultLocale
+  });
+}
+async function GET({ request }) {
+  return getRoutes().handle(request, "GET");
+}
+async function POST({ request }) {
+  return getRoutes().handle(request, "POST");
+}
+async function PATCH({ request }) {
+  return getRoutes().handle(request, "PATCH");
+}
+async function DELETE({ request }) {
+  return getRoutes().handle(request, "DELETE");
+}
+export {
+  DELETE,
+  GET,
+  PATCH,
+  POST
+};

package/dist/endpoints/publish.d.ts

@@ -0,0 +1,5 @@
+declare function POST({ request }: {
+    request: Request;
+}): Promise<Response>;
+
+export { POST };

package/dist/endpoints/publish.js

@@ -0,0 +1,34 @@
+// src/endpoints/publish.ts
+import { getCanciaRuntime } from "virtual:cancia/runtime";
+async function POST({ request }) {
+  const { deployHook, secret } = getCanciaRuntime();
+  if (secret) {
+    const token = request.headers.get("Authorization")?.replace("Bearer ", "").trim();
+    if (token !== secret)
+      return new Response(JSON.stringify({ error: "Unauthorized" }), { status: 401 });
+  }
+  const hook = deployHook ?? process.env.CANCIA_DEPLOY_HOOK;
+  if (!hook)
+    return new Response(
+      JSON.stringify({ error: "No deploy hook configured. Set CANCIA_DEPLOY_HOOK." }),
+      { status: 503 }
+    );
+  try {
+    const res = await fetch(hook, { method: "POST" });
+    if (!res.ok)
+      return new Response(
+        JSON.stringify({ error: `Deploy hook responded with ${res.status}` }),
+        { status: 502 }
+      );
+    return new Response(JSON.stringify({ ok: true }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  } catch {
+    return new Response(JSON.stringify({ error: "Failed to reach deploy hook" }), {
+      status: 502
+    });
+  }
+}
+export {
+  POST
+};

package/dist/endpoints/schemas.d.ts

@@ -0,0 +1,5 @@
+declare function GET({ request }: {
+    request: Request;
+}): Promise<Response>;
+
+export { GET };

package/dist/endpoints/schemas.js

@@ -0,0 +1,20 @@
+import {
+  makeSchemasRoute
+} from "../chunk-YPVZDWTW.js";
+import "../chunk-NG5GJME5.js";
+import "../chunk-QAM5VKAF.js";
+
+// src/endpoints/schemas.ts
+import { getCanciaRuntime } from "virtual:cancia/runtime";
+async function GET({ request }) {
+  const rt = getCanciaRuntime();
+  const route = makeSchemasRoute({
+    projectRoot: rt.projectRoot,
+    schemasPath: rt.schemasPath,
+    secret: rt.secret
+  });
+  return route(request);
+}
+export {
+  GET
+};

package/dist/endpoints/upload.d.ts

@@ -0,0 +1,5 @@
+declare function POST({ request }: {
+    request: Request;
+}): Promise<Response>;
+
+export { POST };