gorsee 0.2.3 → 0.2.5

package/dist-pkg/content/index.js

@@ -0,0 +1,287 @@
+import { readdir, readFile } from "node:fs/promises";
+import { extname, join, relative } from "node:path";
+export function parseFrontmatter(source) {
+  if (!source.startsWith(`---
+`))
+    return { frontmatter: {}, body: source };
+  const end = source.indexOf(`
+---
+`, 4);
+  if (end === -1)
+    return { frontmatter: {}, body: source };
+  const rawFrontmatter = source.slice(4, end), body = source.slice(end + 5), lines = rawFrontmatter.split(`
+`), { value } = parseObjectBlock(lines, 0, 0);
+  return { frontmatter: value, body };
+}
+export function extractExcerpt(body, maxLength = 180) {
+  const clean = body.replace(/^#+\s+/gm, "").replace(/\[(.*?)\]\((.*?)\)/g, "$1").replace(/[*_`>#-]/g, "").replace(/\s+/g, " ").trim();
+  if (clean.length <= maxLength)
+    return clean;
+  return `${clean.slice(0, maxLength).trimEnd()}...`;
+}
+function inferSlug(filePath) {
+  return filePath.replace(/\.[^.]+$/, "").replace(/\.([a-z]{2}(?:-[A-Z]{2})?)$/, "").replace(/\/index$/, "").replace(/\\/g, "/");
+}
+function inferLocale(frontmatter, slug, defaultLocale) {
+  if (typeof frontmatter.locale === "string")
+    return frontmatter.locale;
+  const firstSegment = slug.split("/")[0] ?? "";
+  if (/^[a-z]{2}(-[A-Z]{2})?$/.test(firstSegment))
+    return firstSegment;
+  return defaultLocale ? defaultLocale : null;
+}
+async function collectFiles(root, dir = root) {
+  const entries = await readdir(dir, { withFileTypes: !0 }).catch(() => []), files = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(root, fullPath));
+      continue;
+    }
+    files.push(fullPath);
+  }
+  return files;
+}
+export async function loadContentCollection(options) {
+  const includeExtensions = options.includeExtensions ?? [".md", ".mdx"], defaultLocale = options.defaultLocale ?? "en", files = (await collectFiles(options.dir)).filter((file) => includeExtensions.includes(extname(file))), entries = [];
+  for (const file of files) {
+    const source = await readFile(file, "utf-8"), parsed = parseFrontmatter(source), id = relative(options.dir, file).replace(/\\/g, "/"), slug = inferSlug(id), locale = inferLocale(parsed.frontmatter, slug, defaultLocale), baseEntry = {
+      id,
+      slug,
+      locale,
+      body: parsed.body,
+      excerpt: extractExcerpt(parsed.body),
+      sourcePath: file
+    }, frontmatter = options.validate ? options.validate(parsed.frontmatter, baseEntry) : parsed.frontmatter;
+    entries.push({ ...baseEntry, frontmatter });
+  }
+  return entries;
+}
+export function queryContent(entries, options = {}) {
+  const sorted = [...options.locale ? entries.filter((entry) => entry.locale === options.locale) : [...entries]];
+  switch (options.sortBy) {
+    case "date-asc":
+      sorted.sort((a, b) => String(a.frontmatter.date ?? "").localeCompare(String(b.frontmatter.date ?? "")));
+      break;
+    case "date-desc":
+      sorted.sort((a, b) => String(b.frontmatter.date ?? "").localeCompare(String(a.frontmatter.date ?? "")));
+      break;
+    case "title-asc":
+      sorted.sort((a, b) => String(a.frontmatter.title ?? "").localeCompare(String(b.frontmatter.title ?? "")));
+      break;
+    case "title-desc":
+      sorted.sort((a, b) => String(b.frontmatter.title ?? "").localeCompare(String(a.frontmatter.title ?? "")));
+      break;
+  }
+  return sorted;
+}
+export function getContentEntryBySlug(entries, slug, locale) {
+  return entries.find((entry) => entry.slug === slug && (locale ? entry.locale === locale : !0)) ?? null;
+}
+function parseObjectBlock(lines, startIndex, indent) {
+  const result = {};
+  let index = startIndex;
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (!line.trim() || line.trimStart().startsWith("#")) {
+      index += 1;
+      continue;
+    }
+    const lineIndent = countIndent(line);
+    if (lineIndent < indent)
+      break;
+    if (lineIndent > indent) {
+      index += 1;
+      continue;
+    }
+    const content = line.slice(indent);
+    if (content.startsWith("- "))
+      break;
+    const separator = content.indexOf(":");
+    if (separator === -1) {
+      index += 1;
+      continue;
+    }
+    const key = content.slice(0, separator).trim(), rawValue = content.slice(separator + 1).trim();
+    if (!key) {
+      index += 1;
+      continue;
+    }
+    if (rawValue === "|" || rawValue === ">") {
+      const block = parseBlockScalar(lines, index + 1, indent, rawValue);
+      result[key] = block.value;
+      index = block.nextIndex;
+      continue;
+    }
+    if (rawValue) {
+      result[key] = parseScalar(rawValue);
+      index += 1;
+      continue;
+    }
+    const next = findNextMeaningfulLine(lines, index + 1);
+    if (!next || next.indent <= indent) {
+      result[key] = null;
+      index += 1;
+      continue;
+    }
+    if (next.content.startsWith("- ")) {
+      const sequence = parseArrayBlock(lines, next.index, next.indent);
+      result[key] = sequence.value;
+      index = sequence.nextIndex;
+      continue;
+    }
+    const object = parseObjectBlock(lines, next.index, next.indent);
+    result[key] = object.value;
+    index = object.nextIndex;
+  }
+  return { value: result, nextIndex: index };
+}
+function parseArrayBlock(lines, startIndex, indent) {
+  const result = [];
+  let index = startIndex;
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (!line.trim() || line.trimStart().startsWith("#")) {
+      index += 1;
+      continue;
+    }
+    const lineIndent = countIndent(line);
+    if (lineIndent < indent)
+      break;
+    if (lineIndent !== indent) {
+      index += 1;
+      continue;
+    }
+    const content = line.slice(indent);
+    if (!content.startsWith("- "))
+      break;
+    const itemContent = content.slice(2).trim();
+    if (!itemContent) {
+      const next = findNextMeaningfulLine(lines, index + 1);
+      if (!next || next.indent <= indent) {
+        result.push(null);
+        index += 1;
+        continue;
+      }
+      if (next.content.startsWith("- ")) {
+        const nestedArray = parseArrayBlock(lines, next.index, next.indent);
+        result.push(nestedArray.value);
+        index = nestedArray.nextIndex;
+        continue;
+      }
+      const nestedObject = parseObjectBlock(lines, next.index, next.indent);
+      result.push(nestedObject.value);
+      index = nestedObject.nextIndex;
+      continue;
+    }
+    if (itemContent === "|" || itemContent === ">") {
+      const block = parseBlockScalar(lines, index + 1, indent, itemContent);
+      result.push(block.value);
+      index = block.nextIndex;
+      continue;
+    }
+    if (looksLikeInlineMapping(itemContent)) {
+      const separator = itemContent.indexOf(":"), key = itemContent.slice(0, separator).trim(), rawValue = itemContent.slice(separator + 1).trim(), item = {
+        [key]: rawValue ? parseScalar(rawValue) : null
+      }, next = findNextMeaningfulLine(lines, index + 1);
+      if (next && next.indent > indent && !next.content.startsWith("- ")) {
+        const nested = parseObjectBlock(lines, next.index, next.indent);
+        Object.assign(item, nested.value);
+        result.push(item);
+        index = nested.nextIndex;
+        continue;
+      }
+      result.push(item);
+      index += 1;
+      continue;
+    }
+    result.push(parseScalar(itemContent));
+    index += 1;
+  }
+  return { value: result, nextIndex: index };
+}
+function parseBlockScalar(lines, startIndex, parentIndent, mode) {
+  const first = findNextMeaningfulLine(lines, startIndex);
+  if (!first || first.indent <= parentIndent)
+    return { value: "", nextIndex: startIndex };
+  const blockIndent = first.indent, values = [];
+  let index = startIndex;
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (!line.trim()) {
+      values.push("");
+      index += 1;
+      continue;
+    }
+    if (countIndent(line) < blockIndent)
+      break;
+    values.push(line.slice(blockIndent));
+    index += 1;
+  }
+  return {
+    value: mode === "|" ? values.join(`
+`).trimEnd() : foldBlockScalar(values),
+    nextIndex: index
+  };
+}
+function foldBlockScalar(lines) {
+  const paragraphs = [];
+  let current = "";
+  for (const line of lines) {
+    if (!line.trim()) {
+      if (current) {
+        paragraphs.push(current.trim());
+        current = "";
+      }
+      continue;
+    }
+    current = current ? `${current} ${line.trim()}` : line.trim();
+  }
+  if (current)
+    paragraphs.push(current.trim());
+  return paragraphs.join(`
+
+`);
+}
+function parseScalar(rawValue) {
+  const value = rawValue.trim();
+  if (!value)
+    return "";
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))
+    return value.slice(1, -1);
+  if (value === "true")
+    return !0;
+  if (value === "false")
+    return !1;
+  if (value === "null")
+    return null;
+  if (/^-?\d+(\.\d+)?$/.test(value))
+    return Number(value);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner)
+      return [];
+    return inner.split(",").map((item) => parseScalar(item)).filter((item) => item !== "");
+  }
+  return value;
+}
+function countIndent(line) {
+  return line.length - line.trimStart().length;
+}
+function findNextMeaningfulLine(lines, startIndex) {
+  for (let index = startIndex;index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (!line.trim() || line.trimStart().startsWith("#"))
+      continue;
+    const indent = countIndent(line);
+    return {
+      index,
+      indent,
+      content: line.slice(indent)
+    };
+  }
+  return null;
+}
+function looksLikeInlineMapping(value) {
+  return value.indexOf(":") > 0 && !value.startsWith("http://") && !value.startsWith("https://");
+}

package/dist-pkg/db/index.d.ts

@@ -0,0 +1,3 @@
+export { createDB, type DB } from "./sqlite.js";
+export { createPostgresDB, toPostgresSQL, type PostgresDB, type PostgresClientLike, type PostgresConnectionLike, type PostgresPoolLike, type PostgresQueryResult, } from "./postgres.js";
+export { runMigrations, createMigration, type MigrationResult } from "./migrate.js";

package/dist-pkg/db/index.js

@@ -0,0 +1,6 @@
+export { createDB } from "./sqlite.js";
+export {
+  createPostgresDB,
+  toPostgresSQL
+} from "./postgres.js";
+export { runMigrations, createMigration } from "./migrate.js";

package/dist-pkg/db/migrate.d.ts

@@ -0,0 +1,7 @@
+export interface MigrationResult {
+    applied: string[];
+    skipped: string[];
+    errors: string[];
+}
+export declare function runMigrations(dbPath: string, migrationsDir: string): Promise<MigrationResult>;
+export declare function createMigration(migrationsDir: string, name: string): Promise<string>;

package/dist-pkg/db/migrate.js

@@ -0,0 +1,53 @@
+import { Database } from "bun:sqlite";
+import { readdir, readFile } from "node:fs/promises";
+import { join, extname } from "node:path";
+export async function runMigrations(dbPath, migrationsDir) {
+  const db = new Database(dbPath);
+  db.run("PRAGMA journal_mode=WAL;");
+  db.run(`CREATE TABLE IF NOT EXISTS _migrations (
+    name TEXT PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )`);
+  const applied = new Set(db.query("SELECT name FROM _migrations ORDER BY name").all().map((r) => r.name));
+  let files;
+  try {
+    files = await readdir(migrationsDir);
+  } catch {
+    db.close();
+    return { applied: [], skipped: [], errors: ["migrations/ directory not found"] };
+  }
+  const sqlFiles = files.filter((f) => extname(f) === ".sql").sort(), result = { applied: [], skipped: [], errors: [] };
+  for (const file of sqlFiles) {
+    if (applied.has(file)) {
+      result.skipped.push(file);
+      continue;
+    }
+    try {
+      const sql = await readFile(join(migrationsDir, file), "utf-8");
+      db.run("BEGIN");
+      try {
+        db.run(sql);
+        db.run("INSERT INTO _migrations (name) VALUES (?)", [file]);
+        db.run("COMMIT");
+        result.applied.push(file);
+      } catch (err) {
+        db.run("ROLLBACK");
+        throw err;
+      }
+    } catch (err) {
+      result.errors.push(`${file}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  db.close();
+  return result;
+}
+export async function createMigration(migrationsDir, name) {
+  const { mkdir, writeFile } = await import("node:fs/promises");
+  await mkdir(migrationsDir, { recursive: !0 });
+  const timestamp = new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14), safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase(), filename = `${timestamp}_${safeName}.sql`, filepath = join(migrationsDir, filename);
+  await writeFile(filepath, `-- Migration: ${name}
+-- Created: ${new Date().toISOString()}
+
+`);
+  return filename;
+}

package/dist-pkg/db/postgres.d.ts

@@ -0,0 +1,29 @@
+import type { SafeSQLValue } from "../types/safe-sql.js";
+type Awaitable<T> = T | Promise<T>;
+export interface PostgresQueryResult<Row = unknown> {
+    rows: Row[];
+    rowCount?: number | null;
+}
+export interface PostgresClientLike {
+    query<Row = unknown>(text: string, params?: readonly unknown[]): Awaitable<PostgresQueryResult<Row>>;
+}
+export interface PostgresConnectionLike extends PostgresClientLike {
+    release?(): Awaitable<void>;
+}
+export interface PostgresPoolLike extends PostgresClientLike {
+    connect?(): Promise<PostgresConnectionLike>;
+}
+export interface PostgresDB {
+    get<T>(query: SafeSQLValue): Promise<T | null>;
+    all<T>(query: SafeSQLValue): Promise<T[]>;
+    run(query: SafeSQLValue): Promise<{
+        changes: number;
+    }>;
+    transaction<T>(handler: (db: PostgresDB) => Promise<T>): Promise<T>;
+}
+export declare function toPostgresSQL(query: SafeSQLValue): {
+    text: string;
+    params: readonly unknown[];
+};
+export declare function createPostgresDB(client: PostgresPoolLike): PostgresDB;
+export {};

package/dist-pkg/db/postgres.js

@@ -0,0 +1,59 @@
+export function toPostgresSQL(query) {
+  let index = 0;
+  return {
+    text: query.text.replace(/\?/g, () => `$${++index}`),
+    params: query.params
+  };
+}
+function createBoundPostgresDB(client, beginTransaction) {
+  return {
+    async get(query) {
+      const { text, params } = toPostgresSQL(query);
+      return (await client.query(text, params)).rows[0] ?? null;
+    },
+    async all(query) {
+      const { text, params } = toPostgresSQL(query);
+      return (await client.query(text, params)).rows;
+    },
+    async run(query) {
+      const { text, params } = toPostgresSQL(query);
+      return { changes: (await client.query(text, params)).rowCount ?? 0 };
+    },
+    async transaction(handler) {
+      if (!beginTransaction)
+        return handler(createBoundPostgresDB(client, !1));
+      await client.query("BEGIN");
+      try {
+        const result = await handler(createBoundPostgresDB(client, !1));
+        await client.query("COMMIT");
+        return result;
+      } catch (error) {
+        await client.query("ROLLBACK");
+        throw error;
+      }
+    }
+  };
+}
+export function createPostgresDB(client) {
+  return {
+    async get(query) {
+      return createBoundPostgresDB(client, !0).get(query);
+    },
+    async all(query) {
+      return createBoundPostgresDB(client, !0).all(query);
+    },
+    async run(query) {
+      return createBoundPostgresDB(client, !0).run(query);
+    },
+    async transaction(handler) {
+      if (!client.connect)
+        return createBoundPostgresDB(client, !0).transaction(handler);
+      const connection = await client.connect();
+      try {
+        return await createBoundPostgresDB(connection, !0).transaction(handler);
+      } finally {
+        await connection.release?.();
+      }
+    }
+  };
+}

package/dist-pkg/db/sqlite.d.ts

@@ -0,0 +1,10 @@
+import type { SafeSQLValue } from "../types/safe-sql.js";
+export interface DB {
+    get<T>(query: SafeSQLValue): T | null;
+    all<T>(query: SafeSQLValue): T[];
+    run(query: SafeSQLValue): {
+        changes: number;
+    };
+    close(): void;
+}
+export declare function createDB(path?: string): DB;

package/dist-pkg/db/sqlite.js

@@ -0,0 +1,22 @@
+import { Database } from "bun:sqlite";
+function toBindings(params) {
+  return params;
+}
+export function createDB(path = ":memory:") {
+  const sqlite = new Database(path);
+  sqlite.run("PRAGMA journal_mode=WAL;");
+  return {
+    get(query) {
+      return sqlite.prepare(query.text).get(...toBindings(query.params));
+    },
+    all(query) {
+      return sqlite.prepare(query.text).all(...toBindings(query.params));
+    },
+    run(query) {
+      return { changes: sqlite.prepare(query.text).run(...toBindings(query.params)).changes ?? 0 };
+    },
+    close() {
+      sqlite.close();
+    }
+  };
+}

package/dist-pkg/deploy/cloudflare.d.ts

@@ -0,0 +1,8 @@
+export declare function generateWranglerConfig(name: string): string;
+export declare function generateCloudflareEntry(): string;
+export interface CloudflareRoutesConfig {
+    version: number;
+    include: string[];
+    exclude: string[];
+}
+export declare function generateCloudflareStaticAssets(): CloudflareRoutesConfig;

package/{src/deploy/cloudflare.ts → dist-pkg/deploy/cloudflare.js}

@@ -1,9 +1,6 @@
-// Gorsee.js — Cloudflare Workers/Pages deploy adapter
-
-export function generateWranglerConfig(name: string): string {
-  const today = new Date().toISOString().split("T")[0]
-
-  return `# Gorsee.js — Cloudflare Workers configuration
+export function generateWranglerConfig(name) {
+  const today = new Date().toISOString().split("T")[0];
+  return `# Gorsee.js \u2014 Cloudflare Workers configuration
 # Auto-generated by \`gorsee deploy cloudflare\`
 
 name = "${name}"
@@ -25,16 +22,16 @@ command = "bun run build"
 # Environment variables
 [vars]
 NODE_ENV = "production"
+APP_ORIGIN = "REPLACE_WITH_APP_ORIGIN"
 
 # Production overrides
 [env.production]
 name = "${name}"
 route = { pattern = "*", zone_name = "" }
-`
+`;
 }
-
-export function generateCloudflareEntry(): string {
-  return `// Gorsee.js — Cloudflare Worker entry
+export function generateCloudflareEntry() {
+  return `// Gorsee.js \u2014 Cloudflare Worker entry
 // Auto-generated by \`gorsee deploy cloudflare\`
 
 export default {
@@ -44,11 +41,12 @@ export default {
     ctx: ExecutionContext,
   ): Promise<Response> {
     const url = new URL(request.url)
+    const appOrigin = (env.APP_ORIGIN as string | undefined) ?? url.origin
 
     // Serve static client assets from KV/site
     if (url.pathname.startsWith("/_gorsee/")) {
       const assetPath = url.pathname.slice("/_gorsee/".length)
-      // @ts-expect-error — __STATIC_CONTENT is injected by Cloudflare
+      // @ts-expect-error \u2014 __STATIC_CONTENT is injected by Cloudflare
       const asset = await (env.__STATIC_CONTENT as any)?.get(assetPath)
       if (asset) {
         return new Response(asset, {
@@ -63,7 +61,7 @@ export default {
     // Serve public static files
     const staticExts = [".css", ".ico", ".svg", ".png", ".jpg", ".woff2", ".txt"]
     if (staticExts.some((ext) => url.pathname.endsWith(ext))) {
-      // @ts-expect-error — __STATIC_CONTENT is injected by Cloudflare
+      // @ts-expect-error \u2014 __STATIC_CONTENT is injected by Cloudflare
       const asset = await (env.__STATIC_CONTENT as any)?.get(url.pathname.slice(1))
       if (asset) {
         return new Response(asset, {
@@ -75,23 +73,23 @@ export default {
     // Forward all other requests to Gorsee server handler
     // In production, this imports the built server bundle
     try {
-      const { handleRequest } = await import("./server-handler.js")
-      return await handleRequest(request, env)
+      const rpcPolicy = {
+        // Wire auth/CSRF middleware here for privileged server() calls.
+        // The server handler should prefer app.config.ts security.rpc.middlewares
+        // when no explicit runtime policy is provided.
+        middlewares: [],
+      }
+      const { handleRequest } = await import("./dist/server-handler.js")
+      void appOrigin
+      return await handleRequest(request, env, { rpcPolicy })
     } catch {
       return new Response("Internal Server Error", { status: 500 })
     }
   },
 }
-`
+`;
 }
-
-export interface CloudflareRoutesConfig {
-  version: number
-  include: string[]
-  exclude: string[]
-}
-
-export function generateCloudflareStaticAssets(): CloudflareRoutesConfig {
+export function generateCloudflareStaticAssets() {
   return {
     version: 1,
     include: ["/*"],
@@ -103,7 +101,7 @@ export function generateCloudflareStaticAssets(): CloudflareRoutesConfig {
       "/*.png",
       "/*.jpg",
       "/*.svg",
-      "/*.woff2",
-    ],
-  }
+      "/*.woff2"
+    ]
+  };
 }

package/dist-pkg/deploy/conformance.d.ts

@@ -0,0 +1,21 @@
+export interface DeployArtifactConformanceInput {
+    name: string;
+    content: string;
+    requiredTokens: string[];
+    forbiddenTokens?: string[];
+    format?: "text" | "json" | "toml";
+    requiredPaths?: string[];
+    requiredValues?: Array<{
+        path: string;
+        value: string | number | boolean;
+    }>;
+}
+export interface DeployArtifactConformanceResult {
+    ok: boolean;
+    missing: string[];
+    forbidden: string[];
+    missingPaths: string[];
+    mismatchedValues: string[];
+}
+export declare function validateDeployArtifactConformance(input: DeployArtifactConformanceInput): DeployArtifactConformanceResult;
+export declare function assertDeployArtifactConformance(input: DeployArtifactConformanceInput): void;