@cancia/astro 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antonino Dell'Albani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-22DJVJBR.js

@@ -0,0 +1,169 @@
+import {
+  loadListSchema
+} from "./chunk-NG5GJME5.js";
+import {
+  RevConflictError
+} from "./chunk-7IA5B5CF.js";
+
+// src/routes/lists.ts
+function parseListPath(url) {
+  const path = new URL(url, "http://localhost").pathname;
+  const m = path.match(/^\/api\/cancia\/lists\/([a-z][a-z0-9_]*)(?:\/(.+))?$/);
+  if (!m) return null;
+  const listName = m[1];
+  const rest = m[2];
+  if (!rest) return { kind: "collection", listName };
+  if (rest === "reorder") return { kind: "reorder", listName };
+  if (rest === "_translations") return { kind: "translations", listName };
+  return { kind: "entry", listName, id: rest };
+}
+function getSite(request) {
+  return new URL(request.url).searchParams.get("site");
+}
+function getLocale(request) {
+  return new URL(request.url).searchParams.get("locale");
+}
+function checkAuth(request, secret) {
+  if (!secret) return null;
+  const token = request.headers.get("Authorization")?.replace("Bearer ", "").trim();
+  if (token !== secret) {
+    return json({ error: "Unauthorized" }, 401);
+  }
+  return null;
+}
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function unknownListResponse(listName) {
+  return json({ error: `Unknown list "${listName}"`, code: "UNKNOWN_LIST" }, 404);
+}
+function makeListsRoutes(ctx) {
+  async function handle(request, method) {
+    if (!ctx.storageV2) {
+      return json({ error: "Storage v2 not configured", code: "NO_STORAGE_V2" }, 503);
+    }
+    const deny = checkAuth(request, ctx.secret);
+    if (deny) return deny;
+    const parsed = parseListPath(request.url);
+    if (!parsed) return json({ error: "Bad request" }, 400);
+    const site = getSite(request);
+    if (!site) return json({ error: "Missing ?site=" }, 400);
+    const schema = await loadListSchema(ctx.projectRoot, parsed.listName, ctx.schemasPath);
+    if (!schema) return unknownListResponse(parsed.listName);
+    const { lists } = ctx.storageV2;
+    const requestedLocale = getLocale(request);
+    const writeLocale = requestedLocale ?? ctx.defaultLocale;
+    if (parsed.kind === "translations") {
+      if (method !== "GET") return json({ error: "Method not allowed" }, 405);
+      const statuses = await lists.translations(site, parsed.listName);
+      return json({ translations: statuses });
+    }
+    if (parsed.kind === "collection") {
+      if (method === "GET") {
+        const entries = await lists.list(site, parsed.listName, requestedLocale ?? void 0);
+        return json({ entries });
+      }
+      if (method === "POST") {
+        const body = await request.json().catch(() => null);
+        if (!body || typeof body.data !== "object" || body.data === null) {
+          return json({ error: "Missing or invalid `data` object" }, 400);
+        }
+        const parsedData = schema.validator.safeParse(body.data);
+        if (!parsedData.success) {
+          return json({
+            error: "Validation failed",
+            code: "VALIDATION_FAILED",
+            issues: parsedData.error.issues
+          }, 400);
+        }
+        try {
+          const entry = await lists.create(
+            site,
+            parsed.listName,
+            parsedData.data,
+            writeLocale,
+            body.id
+          );
+          return json({ entry }, 201);
+        } catch (e) {
+          return json({
+            error: e instanceof Error ? e.message : String(e),
+            code: "CREATE_FAILED"
+          }, 409);
+        }
+      }
+      return json({ error: `Method ${method} not allowed` }, 405);
+    }
+    if (parsed.kind === "reorder") {
+      if (method !== "POST") return json({ error: "Method not allowed" }, 405);
+      const body = await request.json().catch(() => null);
+      if (!body || !Array.isArray(body.ids) || !body.ids.every((id2) => typeof id2 === "string")) {
+        return json({ error: "`ids` must be a string array" }, 400);
+      }
+      try {
+        await lists.reorder(site, parsed.listName, body.ids);
+        return json({ ok: true });
+      } catch (e) {
+        return json({
+          error: e instanceof Error ? e.message : String(e),
+          code: "REORDER_FAILED"
+        }, 409);
+      }
+    }
+    const { id } = parsed;
+    if (method === "GET") {
+      const entry = await lists.get(site, parsed.listName, id, writeLocale);
+      if (!entry) return json({ error: "Not found" }, 404);
+      return json({ entry });
+    }
+    if (method === "PATCH") {
+      const body = await request.json().catch(() => null);
+      if (!body || typeof body.data !== "object" || body.data === null) {
+        return json({ error: "Missing or invalid `data` object" }, 400);
+      }
+      if (typeof body._rev !== "string") {
+        return json({ error: "Missing `_rev`", code: "REV_REQUIRED" }, 400);
+      }
+      const parsedData = schema.validator.safeParse(body.data);
+      if (!parsedData.success) {
+        return json({
+          error: "Validation failed",
+          code: "VALIDATION_FAILED",
+          issues: parsedData.error.issues
+        }, 400);
+      }
+      try {
+        const entry = await lists.update(
+          site,
+          parsed.listName,
+          id,
+          writeLocale,
+          parsedData.data,
+          body._rev
+        );
+        return json({ entry });
+      } catch (e) {
+        if (e instanceof RevConflictError) {
+          return json({ error: e.message, code: "REV_CONFLICT" }, 409);
+        }
+        return json({
+          error: e instanceof Error ? e.message : String(e),
+          code: "UPDATE_FAILED"
+        }, 400);
+      }
+    }
+    if (method === "DELETE") {
+      await lists.delete(site, parsed.listName, id, writeLocale);
+      return json({ ok: true });
+    }
+    return json({ error: `Method ${method} not allowed` }, 405);
+  }
+  return { handle };
+}
+
+export {
+  makeListsRoutes
+};

package/dist/chunk-5IPHDIC6.js

@@ -0,0 +1,19 @@
+// src/upload-validate.ts
+var SITE_RE = /^[a-z0-9][a-z0-9._-]*$/i;
+function isValidSite(site) {
+  return SITE_RE.test(site);
+}
+function detectImageType(buf) {
+  const startsWith = (sig, offset = 0) => sig.every((b, i) => buf[offset + i] === b);
+  if (startsWith([255, 216, 255])) return { mime: "image/jpeg", ext: "jpg" };
+  if (startsWith([137, 80, 78, 71, 13, 10, 26, 10])) return { mime: "image/png", ext: "png" };
+  if (startsWith([71, 73, 70, 56])) return { mime: "image/gif", ext: "gif" };
+  if (startsWith([82, 73, 70, 70]) && startsWith([87, 69, 66, 80], 8)) return { mime: "image/webp", ext: "webp" };
+  if (startsWith([102, 116, 121, 112], 4) && (startsWith([97, 118, 105, 102], 8) || startsWith([97, 118, 105, 115], 8))) return { mime: "image/avif", ext: "avif" };
+  return null;
+}
+
+export {
+  isValidSite,
+  detectImageType
+};

package/dist/chunk-7IA5B5CF.js

@@ -0,0 +1,11 @@
+// src/storage/types.ts
+var RevConflictError = class extends Error {
+  constructor(message = "Revision mismatch \u2014 item was modified by another writer") {
+    super(message);
+    this.name = "RevConflictError";
+  }
+};
+
+export {
+  RevConflictError
+};

package/dist/chunk-DGCGIEFD.js

@@ -0,0 +1,14 @@
+// src/runtime.ts
+var _runtime = null;
+function setCanciaRuntime(runtime) {
+  _runtime = runtime;
+}
+function getCanciaRuntime() {
+  if (!_runtime) throw new Error("[cancia] Runtime not initialised. This is a bug.");
+  return _runtime;
+}
+
+export {
+  setCanciaRuntime,
+  getCanciaRuntime
+};

package/dist/chunk-NG5GJME5.js

@@ -0,0 +1,39 @@
+// src/schema/loader.ts
+import { existsSync, statSync } from "fs";
+import { pathToFileURL } from "url";
+import { join } from "path";
+var _cache = null;
+var _cachedPath = null;
+var _cachedMtime = 0;
+function resolveSchemasPath(projectRoot, overridePath) {
+  if (overridePath) {
+    return existsSync(overridePath) ? overridePath : null;
+  }
+  const tsPath = join(projectRoot, "src", "cms", "schemas.ts");
+  if (existsSync(tsPath)) return tsPath;
+  const jsPath = join(projectRoot, "src", "cms", "schemas.js");
+  if (existsSync(jsPath)) return jsPath;
+  return null;
+}
+async function loadSchemas(projectRoot, overridePath) {
+  const path = resolveSchemasPath(projectRoot, overridePath);
+  if (!path) return {};
+  const mtime = statSync(path).mtimeMs;
+  if (_cache && _cachedPath === path && _cachedMtime === mtime) return _cache;
+  const url = pathToFileURL(path).href;
+  const mod = await import(`${url}?mtime=${mtime}`);
+  const schemas = mod.schemas ?? mod.default ?? {};
+  _cache = schemas;
+  _cachedPath = path;
+  _cachedMtime = mtime;
+  return schemas;
+}
+async function loadListSchema(projectRoot, listName, overridePath) {
+  const schemas = await loadSchemas(projectRoot, overridePath);
+  return schemas[listName] ?? null;
+}
+
+export {
+  loadSchemas,
+  loadListSchema
+};

package/dist/chunk-QAM5VKAF.js

@@ -0,0 +1,73 @@
+// src/schema/index.ts
+import { z } from "zod";
+function defineList(opts) {
+  return {
+    label: opts.label,
+    labelSingular: opts.labelSingular ?? opts.label.replace(/s$/, ""),
+    titleField: opts.titleField,
+    bodyField: opts.bodyField,
+    slugField: opts.slugField,
+    fields: opts.fields,
+    validator: z.object(opts.fields)
+  };
+}
+function humanise(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/[_-]/g, " ").replace(/^\w/, (c) => c.toUpperCase()).trim();
+}
+function inferWidget(prop, label) {
+  if (prop.widget) return prop.widget;
+  if (prop.enum) return "select";
+  if (prop.type === "boolean") return "checkbox";
+  if (prop.type === "number" || prop.type === "integer") return "number";
+  if (prop.type === "string") {
+    if (prop.format === "uri" || prop.format === "url") return "url";
+    if (prop.format === "email") return "email";
+    if (prop.format === "date-time" || prop.format === "date") return "datetime";
+    if (label.toLowerCase() === "body" || label.toLowerCase() === "content") return "textarea";
+    if (prop.maxLength && prop.maxLength > 200) return "textarea";
+    return "text";
+  }
+  return "text";
+}
+function describeProperty(name, prop, required) {
+  const label = prop.label ?? humanise(name);
+  const desc = {
+    name,
+    label,
+    widget: inferWidget(prop, label),
+    required
+  };
+  if (prop.description) desc.description = prop.description;
+  if (prop.placeholder) desc.placeholder = prop.placeholder;
+  if (prop.minLength !== void 0) desc.minLength = prop.minLength;
+  if (prop.maxLength !== void 0) desc.maxLength = prop.maxLength;
+  if (prop.minimum !== void 0) desc.min = prop.minimum;
+  if (prop.maximum !== void 0) desc.max = prop.maximum;
+  if (prop.enum) desc.options = prop.enum;
+  return desc;
+}
+function describeList(name, schema) {
+  const json = z.toJSONSchema(schema.validator, {
+    metadata: z.globalRegistry
+  });
+  const properties = json.properties ?? {};
+  const requiredSet = new Set(json.required ?? []);
+  const fields = Object.keys(schema.fields).map(
+    (fieldName) => describeProperty(fieldName, properties[fieldName] ?? {}, requiredSet.has(fieldName))
+  );
+  return {
+    name,
+    label: schema.label,
+    labelSingular: schema.labelSingular,
+    titleField: schema.titleField,
+    bodyField: schema.bodyField,
+    slugField: schema.slugField,
+    fields
+  };
+}
+
+export {
+  z,
+  defineList,
+  describeList
+};

package/dist/chunk-YPVZDWTW.js

@@ -0,0 +1,34 @@
+import {
+  loadSchemas
+} from "./chunk-NG5GJME5.js";
+import {
+  describeList
+} from "./chunk-QAM5VKAF.js";
+
+// src/routes/schemas.ts
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function makeSchemasRoute(ctx) {
+  return async function schemasRoute(request) {
+    if (ctx.secret) {
+      const token = request.headers.get("Authorization")?.replace("Bearer ", "").trim();
+      if (token !== ctx.secret) {
+        return json({ error: "Unauthorized" }, 401);
+      }
+    }
+    const schemas = await loadSchemas(ctx.projectRoot, ctx.schemasPath);
+    const descriptions = {};
+    for (const [name, schema] of Object.entries(schemas)) {
+      descriptions[name] = describeList(name, schema);
+    }
+    return json({ schemas: descriptions });
+  };
+}
+
+export {
+  makeSchemasRoute
+};