@cancia/astro 0.1.0 → 0.2.0

package/dist/chunk-SXKZ2WUL.js

@@ -0,0 +1,305 @@
+// src/storage/sqlite.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var _db = null;
+function createDB(dbPath) {
+  const Database = require2("better-sqlite3");
+  const sqlite = new Database(dbPath);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS cancia_content (
+      id         INTEGER PRIMARY KEY AUTOINCREMENT,
+      site       TEXT NOT NULL,
+      key        TEXT NOT NULL,
+      lang       TEXT NOT NULL,
+      value      TEXT NOT NULL,
+      updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      UNIQUE(site, key, lang)
+    )
+  `);
+  return {
+    get: sqlite.prepare(
+      "SELECT value FROM cancia_content WHERE site=? AND key=? AND lang=?"
+    ),
+    set: sqlite.prepare(
+      `INSERT INTO cancia_content (site, key, lang, value, updated_at)
+       VALUES (?, ?, ?, ?, unixepoch())
+       ON CONFLICT(site, key, lang) DO UPDATE SET value=excluded.value, updated_at=unixepoch()`
+    ),
+    getAll: sqlite.prepare(
+      "SELECT key, lang, value FROM cancia_content WHERE site=?"
+    ),
+    delete: sqlite.prepare(
+      "DELETE FROM cancia_content WHERE site=? AND key=? AND lang=?"
+    )
+  };
+}
+function getDB(dbPath) {
+  if (!_db) _db = createDB(dbPath);
+  return _db;
+}
+function createSQLiteAdapter(dbPath) {
+  const path = dbPath ?? process.cwd() + "/cancia.db";
+  return {
+    async get(site, key, lang) {
+      const row = getDB(path).get.get(site, key, lang);
+      return row?.value ?? null;
+    },
+    async set(site, key, lang, value) {
+      getDB(path).set.run(site, key, lang, value);
+    },
+    async getAll(site) {
+      const rows = getDB(path).getAll.all(site);
+      return Object.fromEntries(rows.map((r) => [`${r.key}.${r.lang}`, r.value]));
+    },
+    async delete(site, key, lang) {
+      getDB(path).delete.run(site, key, lang);
+    }
+  };
+}
+
+// src/storage/github-client.ts
+function toBase64(text) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(text, "utf-8").toString("base64");
+  }
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary);
+}
+function createGitHubClient(opts) {
+  const { repo, branch, token, committer } = opts;
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  const apiBase = (opts.apiBase ?? "https://api.github.com").replace(/\/$/, "");
+  if (!doFetch) {
+    throw new Error("createGitHubClient: no fetch available (pass opts.fetch)");
+  }
+  const headers = () => ({
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  });
+  const contentsUrl = (path) => {
+    const encoded = path.split("/").map((seg) => encodeURIComponent(seg)).join("/");
+    return `${apiBase}/repos/${repo}/contents/${encoded}`;
+  };
+  async function getFileSha(path) {
+    const url = `${contentsUrl(path)}?ref=${encodeURIComponent(branch)}`;
+    const res = await doFetch(url, { method: "GET", headers: headers() });
+    if (res.status === 404) return null;
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`GitHub getFileSha ${path} failed: ${res.status} ${detail}`);
+    }
+    const body = await res.json();
+    return body.sha ?? null;
+  }
+  async function putFile(file, message) {
+    const sha = await getFileSha(file.path);
+    const payload = {
+      message,
+      content: toBase64(file.content),
+      branch
+    };
+    if (sha) payload.sha = sha;
+    if (committer) payload.committer = committer;
+    const res = await doFetch(contentsUrl(file.path), {
+      method: "PUT",
+      headers: headers(),
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`GitHub commit ${file.path} failed: ${res.status} ${detail}`);
+    }
+  }
+  async function commitFiles(files, message) {
+    for (const file of files) {
+      await putFile(file, message);
+    }
+  }
+  return { getFileSha, commitFiles };
+}
+
+// src/storage/git-backed.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+function createGitBackedAdapter(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const branch = opts.branch ?? "main";
+  const debounceMs = opts.debounceMs ?? 3e3;
+  const commitMessage = opts.commitMessage ?? "Cancia: content update";
+  const warn = opts.warn ?? ((m) => console.warn(m));
+  const onError = opts.onError ?? ((m, e) => console.error(m, e));
+  const kvPath = opts.contentPaths?.kvPath ?? join(projectRoot, "cancia-content.json");
+  const pagesPath = opts.contentPaths?.pagesPath ?? join(projectRoot, ".cancia", "pages.json");
+  const listsDir = opts.contentPaths?.listsDir ?? join(projectRoot, ".cancia", "lists");
+  const token = opts.token ?? process.env.CANCIA_GITHUB_TOKEN ?? "";
+  let client = null;
+  if (opts.client) {
+    client = opts.client;
+  } else if (token) {
+    client = createGitHubClient({
+      repo: opts.repo,
+      branch,
+      token,
+      committer: opts.committer,
+      fetch: opts.fetch,
+      apiBase: opts.apiBase
+    });
+  }
+  const gitEnabled = client !== null;
+  if (!gitEnabled) {
+    warn(
+      "[cancia] Git-backed storage: no GitHub token (CANCIA_GITHUB_TOKEN) \u2014 running local-only. Edits save to disk but are NOT committed/pushed."
+    );
+  }
+  const dirty = /* @__PURE__ */ new Set();
+  let timer = null;
+  let flushing = null;
+  let rerunRequested = false;
+  function toRepoPath(absPath) {
+    return relative(projectRoot, absPath).split("\\").join("/");
+  }
+  function markDirty(absPath) {
+    dirty.add(absPath);
+  }
+  function markListDirty(listName, site) {
+    const siteDir = join(listsDir, listName, site);
+    if (!existsSync(siteDir)) return;
+    const walk = (dir) => {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) walk(full);
+        else if (entry.isFile()) markDirty(full);
+      }
+    };
+    walk(siteDir);
+  }
+  function scheduleFlush() {
+    if (!gitEnabled) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      void runFlush();
+    }, debounceMs);
+  }
+  async function runFlush() {
+    if (flushing) {
+      rerunRequested = true;
+      return flushing;
+    }
+    flushing = doFlush().finally(() => {
+      flushing = null;
+      if (rerunRequested) {
+        rerunRequested = false;
+        void runFlush();
+      }
+    });
+    return flushing;
+  }
+  async function doFlush() {
+    if (!client || dirty.size === 0) return;
+    const batch = [...dirty];
+    const files = [];
+    for (const abs of batch) {
+      if (!existsSync(abs) || !statSync(abs).isFile()) continue;
+      files.push({ path: toRepoPath(abs), content: readFileSync(abs, "utf-8") });
+    }
+    if (files.length === 0) {
+      for (const abs of batch) dirty.delete(abs);
+      return;
+    }
+    try {
+      await client.commitFiles(files, commitMessage);
+      for (const abs of batch) dirty.delete(abs);
+    } catch (err) {
+      onError(
+        "[cancia] Git-backed storage: commit failed \u2014 data saved locally, will retry on next flush.",
+        err
+      );
+      throw err;
+    }
+  }
+  async function flush() {
+    if (!gitEnabled) return;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    await runFlush();
+  }
+  const kv = {
+    get: (site, key, lang) => opts.local.kv.get(site, key, lang),
+    getAll: (site) => opts.local.kv.getAll(site),
+    async set(site, key, lang, value) {
+      await opts.local.kv.set(site, key, lang, value);
+      markDirty(kvPath);
+      scheduleFlush();
+    },
+    async delete(site, key, lang) {
+      await opts.local.kv.delete(site, key, lang);
+      markDirty(kvPath);
+      scheduleFlush();
+    }
+  };
+  const pages = {
+    get: (site, route) => opts.local.pages.get(site, route),
+    list: (site) => opts.local.pages.list(site),
+    async set(site, route, meta, rev) {
+      const result = await opts.local.pages.set(site, route, meta, rev);
+      markDirty(pagesPath);
+      scheduleFlush();
+      return result;
+    },
+    async delete(site, route) {
+      await opts.local.pages.delete(site, route);
+      markDirty(pagesPath);
+      scheduleFlush();
+    }
+  };
+  const lists = {
+    list: (site, listName, locale) => opts.local.lists.list(site, listName, locale),
+    get: (site, listName, id, locale) => opts.local.lists.get(site, listName, id, locale),
+    translations: (site, listName) => opts.local.lists.translations(site, listName),
+    async create(site, listName, data, locale, id) {
+      const entry = await opts.local.lists.create(site, listName, data, locale, id);
+      markListDirty(listName, site);
+      scheduleFlush();
+      return entry;
+    },
+    async update(site, listName, id, locale, data, rev) {
+      const entry = await opts.local.lists.update(site, listName, id, locale, data, rev);
+      markListDirty(listName, site);
+      scheduleFlush();
+      return entry;
+    },
+    async delete(site, listName, id, locale) {
+      await opts.local.lists.delete(site, listName, id, locale);
+      markListDirty(listName, site);
+      scheduleFlush();
+    },
+    async reorder(site, listName, ids) {
+      await opts.local.lists.reorder(site, listName, ids);
+      markListDirty(listName, site);
+      scheduleFlush();
+    }
+  };
+  const git = {
+    flush,
+    get gitEnabled() {
+      return gitEnabled;
+    },
+    pendingPaths() {
+      return [...dirty].map(toRepoPath);
+    }
+  };
+  return { kv, pages, lists, git };
+}
+
+export {
+  createSQLiteAdapter,
+  createGitHubClient,
+  createGitBackedAdapter
+};

package/dist/index.d.ts

@@ -5,7 +5,7 @@ import { U as UploadHandler } from './upload-DwCGjXbz.js';
 export { m as makeLocalUploadHandler } from './upload-DwCGjXbz.js';
 export { CanciaLoaderOptions, canciaLoader } from './loader/index.js';
 export { FieldDescription, FieldMeta, FieldMetaBase, FieldWidget, ListDescription, ListSchema, SchemasModule, defineField, defineList, describeList } from './schema/index.js';
-export { createJsonFileAdapter, createJsonFileAdapterV2, createSQLiteAdapter } from './storage/index.js';
+export { GitBackedContentPaths, GitBackedControls, GitBackedOptions, GitBackedStorage, createGitBackedAdapter, createJsonFileAdapter, createJsonFileAdapterV2, createSQLiteAdapter } from './storage/index.js';
 export { z } from 'zod';
 import 'astro/loaders';
 import './portable-text-BikSqS9T.js';

package/dist/index.js

@@ -18,8 +18,9 @@ import {
   canciaLoader
 } from "./chunk-337LJIKX.js";
 import {
+  createGitBackedAdapter,
   createSQLiteAdapter
-} from "./chunk-AE4SIY24.js";
+} from "./chunk-SXKZ2WUL.js";
 import {
   createJsonFileAdapter,
   createJsonFileAdapterV2
@@ -645,6 +646,7 @@ export {
   RevConflictError,
   canciaIntegration,
   canciaLoader,
+  createGitBackedAdapter,
   createJsonFileAdapter,
   createJsonFileAdapterV2,
   createSQLiteAdapter,

package/dist/storage/index.d.ts

@@ -17,4 +17,113 @@ declare function createJsonFileAdapterV2(opts?: JsonFileV2Options): CanciaStorag
 
 declare function createSQLiteAdapter(dbPath?: string): CanciaStorage;
 
-export { CanciaStorage, CanciaStorageV2, createJsonFileAdapter, createJsonFileAdapterV2, createSQLiteAdapter };
+/** Minimal fetch signature — matches the global `fetch` we depend on. */
+type FetchLike = (input: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}>;
+interface GitHubCommitter {
+    name: string;
+    email: string;
+}
+interface GitHubClientOptions {
+    /** "owner/name" */
+    repo: string;
+    /** Branch to commit onto, e.g. "main". */
+    branch: string;
+    /** Fine-grained PAT with contents:write on the one repo. */
+    token: string;
+    /** Optional committer identity. GitHub uses the token's user if omitted. */
+    committer?: GitHubCommitter;
+    /** Injectable fetch (defaults to global fetch) — tests mock this. */
+    fetch?: FetchLike;
+    /** API base — defaults to https://api.github.com. Overridable for tests. */
+    apiBase?: string;
+}
+interface CommitFile {
+    /** Repo-relative path, forward slashes, no leading slash. */
+    path: string;
+    /** Raw file content (UTF-8 text). Encoded to base64 before PUT. */
+    content: string;
+}
+interface GitHubClient {
+    /** Current blob sha for `path`, or null if the file doesn't exist yet. */
+    getFileSha(path: string): Promise<string | null>;
+    /**
+     * Commit each file to the branch. Updates pass the current sha; creates omit
+     * it. Resolves once every PUT succeeds; rejects (without partial silence) if
+     * any PUT fails so the caller can keep the batch dirty and retry.
+     */
+    commitFiles(files: CommitFile[], message: string): Promise<void>;
+}
+declare function createGitHubClient(opts: GitHubClientOptions): GitHubClient;
+
+interface GitBackedContentPaths {
+    /** KV file path. Default <projectRoot>/cancia-content.json. */
+    kvPath?: string;
+    /** Pages file path. Default <projectRoot>/.cancia/pages.json. */
+    pagesPath?: string;
+    /** Lists directory. Default <projectRoot>/.cancia/lists. */
+    listsDir?: string;
+}
+interface GitBackedOptions {
+    /** The wrapped local adapter — the on-disk source of truth. */
+    local: CanciaStorageV2;
+    /** "owner/name" of the GitHub repo whose builds carry the content. */
+    repo: string;
+    /** Branch to commit onto. Default "main". */
+    branch?: string;
+    /**
+     * GitHub PAT. Reads CANCIA_GITHUB_TOKEN if omitted. When absent entirely the
+     * adapter runs in local-only mode (disk writes only; no commits) + warns once.
+     */
+    token?: string;
+    /** Optional committer identity for commits. */
+    committer?: GitHubCommitter;
+    /**
+     * Project root the local adapter writes under — needed to turn absolute
+     * on-disk paths into repo-relative commit paths. Default process.cwd().
+     */
+    projectRoot?: string;
+    /** Override where the local adapter's content lives (must match `local`). */
+    contentPaths?: GitBackedContentPaths;
+    /** Quiet window (ms) before a flush fires. Default 3000. */
+    debounceMs?: number;
+    /** Commit message for content updates. */
+    commitMessage?: string;
+    /** Injected GitHub client (tests pass a mock). Overrides token/fetch. */
+    client?: GitHubClient;
+    /** Injected fetch, forwarded to the default GitHub client. */
+    fetch?: FetchLike;
+    /** API base override, forwarded to the default GitHub client (tests). */
+    apiBase?: string;
+    /** Warn sink (tests capture). Default console.warn. */
+    warn?: (msg: string) => void;
+    /** Error sink for push failures (tests capture). Default console.error. */
+    onError?: (msg: string, err: unknown) => void;
+}
+/** The extra control surface the git adapter adds on top of CanciaStorageV2. */
+interface GitBackedControls {
+    /**
+     * Force any pending dirty files to commit now, bypassing the debounce.
+     * Resolves once the flush completes (or rejects if the push failed — the
+     * files stay dirty for the next flush). For tests + graceful shutdown.
+     */
+    flush(): Promise<void>;
+    /** True if git commits are active (token present). */
+    readonly gitEnabled: boolean;
+    /** Snapshot of currently-dirty repo-relative paths (for tests/inspection). */
+    pendingPaths(): string[];
+}
+type GitBackedStorage = CanciaStorageV2 & {
+    git: GitBackedControls;
+};
+declare function createGitBackedAdapter(opts: GitBackedOptions): GitBackedStorage;
+
+export { CanciaStorage, CanciaStorageV2, type CommitFile, type GitBackedContentPaths, type GitBackedControls, type GitBackedOptions, type GitBackedStorage, type GitHubClient, type GitHubClientOptions, type GitHubCommitter, createGitBackedAdapter, createGitHubClient, createJsonFileAdapter, createJsonFileAdapterV2, createSQLiteAdapter };

package/dist/storage/index.js

@@ -1,6 +1,8 @@
 import {
+  createGitBackedAdapter,
+  createGitHubClient,
   createSQLiteAdapter
-} from "../chunk-AE4SIY24.js";
+} from "../chunk-SXKZ2WUL.js";
 import {
   createJsonFileAdapter,
   createJsonFileAdapterV2
@@ -10,6 +12,8 @@ import {
 } from "../chunk-7IA5B5CF.js";
 export {
   RevConflictError,
+  createGitBackedAdapter,
+  createGitHubClient,
   createJsonFileAdapter,
   createJsonFileAdapterV2,
   createSQLiteAdapter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cancia/astro",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Astro integration for Cancia CMS — inline editing with zero separate server",
   "license": "MIT",
   "repository": {

package/dist/chunk-AE4SIY24.js

@@ -1,63 +0,0 @@
-// src/storage/sqlite.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var _db = null;
-function createDB(dbPath) {
-  const Database = require2("better-sqlite3");
-  const sqlite = new Database(dbPath);
-  sqlite.pragma("journal_mode = WAL");
-  sqlite.exec(`
-    CREATE TABLE IF NOT EXISTS cancia_content (
-      id         INTEGER PRIMARY KEY AUTOINCREMENT,
-      site       TEXT NOT NULL,
-      key        TEXT NOT NULL,
-      lang       TEXT NOT NULL,
-      value      TEXT NOT NULL,
-      updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
-      UNIQUE(site, key, lang)
-    )
-  `);
-  return {
-    get: sqlite.prepare(
-      "SELECT value FROM cancia_content WHERE site=? AND key=? AND lang=?"
-    ),
-    set: sqlite.prepare(
-      `INSERT INTO cancia_content (site, key, lang, value, updated_at)
-       VALUES (?, ?, ?, ?, unixepoch())
-       ON CONFLICT(site, key, lang) DO UPDATE SET value=excluded.value, updated_at=unixepoch()`
-    ),
-    getAll: sqlite.prepare(
-      "SELECT key, lang, value FROM cancia_content WHERE site=?"
-    ),
-    delete: sqlite.prepare(
-      "DELETE FROM cancia_content WHERE site=? AND key=? AND lang=?"
-    )
-  };
-}
-function getDB(dbPath) {
-  if (!_db) _db = createDB(dbPath);
-  return _db;
-}
-function createSQLiteAdapter(dbPath) {
-  const path = dbPath ?? process.cwd() + "/cancia.db";
-  return {
-    async get(site, key, lang) {
-      const row = getDB(path).get.get(site, key, lang);
-      return row?.value ?? null;
-    },
-    async set(site, key, lang, value) {
-      getDB(path).set.run(site, key, lang, value);
-    },
-    async getAll(site) {
-      const rows = getDB(path).getAll.all(site);
-      return Object.fromEntries(rows.map((r) => [`${r.key}.${r.lang}`, r.value]));
-    },
-    async delete(site, key, lang) {
-      getDB(path).delete.run(site, key, lang);
-    }
-  };
-}
-
-export {
-  createSQLiteAdapter
-};