kernelcms 0.1.0

package/dist/postgres.js

@@ -0,0 +1,459 @@
+// ../db-postgres/src/index.ts
+import pg from "pg";
+var { Pool } = pg;
+var SQL_TYPE = {
+  text: "text",
+  integer: "integer",
+  real: "double precision",
+  boolean: "boolean",
+  timestamp: "timestamptz",
+  json: "jsonb"
+};
+function quote(ident) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(ident)) {
+    throw new Error(`Invalid SQL identifier: ${ident}`);
+  }
+  return `"${ident}"`;
+}
+var Params = class {
+  values = [];
+  next(value) {
+    this.values.push(value);
+    return `$${this.values.length}`;
+  }
+};
+var PostgresAdapter = class {
+  kind = "db";
+  name = "postgres";
+  contractVersion = "1.0";
+  capabilities = {
+    transactions: true,
+    joins: "application",
+    jsonQuery: false,
+    fullTextSearch: false,
+    returning: true
+  };
+  pool = null;
+  logger = null;
+  options;
+  tables = /* @__PURE__ */ new Map();
+  allowedCols = /* @__PURE__ */ new Map();
+  savepointSeq = 0;
+  constructor(options) {
+    this.options = options;
+  }
+  async init(ctx) {
+    this.logger = ctx.logger;
+    const url = this.options.url ?? process.env.DATABASE_URL;
+    if (!url && !this.options.pool) {
+      throw new Error(
+        "PostgreSQL adapter requires a connection string. Set DATABASE_URL or pass `url` to postgresAdapter()."
+      );
+    }
+    const ssl = this.options.ssl === true ? { rejectUnauthorized: false } : this.options.ssl;
+    const config = {
+      connectionString: url,
+      max: this.options.max ?? 10,
+      ...ssl === void 0 ? {} : { ssl },
+      ...this.options.pool
+    };
+    this.pool = new Pool(config);
+    const probe = await this.pool.connect();
+    probe.release();
+    this.logger.info("postgres connected");
+  }
+  requirePool() {
+    if (!this.pool) throw new Error("Postgres adapter not initialized. Did you call initKernel()?");
+    return this.pool;
+  }
+  table(name) {
+    const t = this.tables.get(name);
+    if (!t) throw new Error(`Unknown table "${name}". Run migrations first.`);
+    return t;
+  }
+  allowed(table) {
+    return this.allowedCols.get(table) ?? /* @__PURE__ */ new Set(["id"]);
+  }
+  async migrate(schema) {
+    const pool = this.requirePool();
+    const report = { createdTables: [], addedColumns: [], statements: [] };
+    for (const table of schema.tables) {
+      this.tables.set(table.table, table);
+      const allowed = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
+      for (const c of table.columns) allowed.add(c.name);
+      this.allowedCols.set(table.table, allowed);
+      const existing = await pool.query(
+        `SELECT column_name FROM information_schema.columns
+         WHERE table_schema = current_schema() AND table_name = $1`,
+        [table.table]
+      );
+      if (existing.rows.length === 0) {
+        const sql = this.createTableSql(table);
+        await pool.query(sql);
+        report.createdTables.push(table.table);
+        report.statements.push(sql);
+      } else {
+        const have = new Set(existing.rows.map((r) => String(r.column_name)));
+        for (const col of table.columns) {
+          if (!have.has(col.name)) {
+            const sql = `ALTER TABLE ${quote(table.table)} ADD COLUMN ${this.columnSql(col)};`;
+            await pool.query(sql);
+            report.addedColumns.push(`${table.table}.${col.name}`);
+            report.statements.push(sql);
+          }
+        }
+      }
+      for (const col of table.columns) {
+        if (col.indexed && !col.unique) {
+          const idx = `idx_${table.table}_${col.name}`;
+          await pool.query(
+            `CREATE INDEX IF NOT EXISTS ${quote(idx)} ON ${quote(table.table)} (${quote(col.name)});`
+          );
+        }
+      }
+    }
+    this.logger?.info(
+      `migrated: ${report.createdTables.length} table(s) created, ${report.addedColumns.length} column(s) added`
+    );
+    return report;
+  }
+  columnSql(col) {
+    const parts = [quote(col.name), SQL_TYPE[col.type]];
+    if (col.unique) parts.push("UNIQUE");
+    return parts.join(" ");
+  }
+  createTableSql(table) {
+    const cols = [`${quote("id")} text PRIMARY KEY`];
+    for (const col of table.columns) cols.push(this.columnSql(col));
+    if (table.timestamps) {
+      cols.push(`${quote("createdAt")} timestamptz`);
+      cols.push(`${quote("updatedAt")} timestamptz`);
+    }
+    return `CREATE TABLE IF NOT EXISTS ${quote(table.table)} (
+  ${cols.join(",\n  ")}
+);`;
+  }
+  // -- value codecs ---------------------------------------------------------
+  encode(col, value) {
+    if (value === void 0 || value === null) return null;
+    switch (col.type) {
+      case "boolean":
+        return Boolean(value);
+      case "json":
+        return JSON.stringify(value);
+      case "integer":
+        return Math.trunc(Number(value));
+      case "real":
+        return Number(value);
+      case "timestamp":
+        return value instanceof Date ? value.toISOString() : String(value);
+      default:
+        return String(value);
+    }
+  }
+  decode(col, value) {
+    if (value === void 0 || value === null) return null;
+    switch (col.type) {
+      case "boolean":
+        return Boolean(value);
+      case "json":
+        if (typeof value === "string") {
+          try {
+            return JSON.parse(value);
+          } catch {
+            return null;
+          }
+        }
+        return value;
+      case "timestamp":
+        return value instanceof Date ? value.toISOString() : value;
+      default:
+        return value;
+    }
+  }
+  decodeRow(table, raw) {
+    const out = { id: raw.id };
+    if ("createdAt" in raw) out.createdAt = raw.createdAt instanceof Date ? raw.createdAt.toISOString() : raw.createdAt;
+    if ("updatedAt" in raw) out.updatedAt = raw.updatedAt instanceof Date ? raw.updatedAt.toISOString() : raw.updatedAt;
+    for (const col of table.columns) out[col.name] = this.decode(col, raw[col.name]);
+    return out;
+  }
+  colByName(table) {
+    const m = /* @__PURE__ */ new Map();
+    for (const c of table.columns) m.set(c.name, c);
+    return m;
+  }
+  // -- where compilation ----------------------------------------------------
+  buildWhere(where, table, cols, allowed, params) {
+    const clauses = [];
+    if (where.and?.length) {
+      const sub = where.and.map((w) => this.buildWhere(w, table, cols, allowed, params)).filter(Boolean);
+      if (sub.length) clauses.push(`(${sub.join(" AND ")})`);
+    }
+    if (where.or?.length) {
+      const sub = where.or.map((w) => this.buildWhere(w, table, cols, allowed, params)).filter(Boolean);
+      if (sub.length) clauses.push(`(${sub.join(" OR ")})`);
+    }
+    for (const [field, cond] of Object.entries(where)) {
+      if (field === "and" || field === "or" || cond === void 0) continue;
+      if (!allowed.has(field)) throw new Error(`Cannot filter on unknown field "${field}" of "${table.table}".`);
+      clauses.push(this.fieldClause(field, cond, cols.get(field), params));
+    }
+    return clauses.length ? clauses.join(" AND ") : "";
+  }
+  encodeOperand(col, operand) {
+    if (col) return this.encode(col, operand);
+    if (typeof operand === "boolean") return operand;
+    return operand;
+  }
+  fieldClause(field, cond, col, params) {
+    const id = quote(field);
+    const parts = [];
+    for (const [op, operand] of Object.entries(cond)) {
+      switch (op) {
+        case "equals":
+          if (operand === null) parts.push(`${id} IS NULL`);
+          else parts.push(`${id} = ${params.next(this.encodeOperand(col, operand))}`);
+          break;
+        case "not_equals":
+          if (operand === null) parts.push(`${id} IS NOT NULL`);
+          else parts.push(`(${id} <> ${params.next(this.encodeOperand(col, operand))} OR ${id} IS NULL)`);
+          break;
+        case "in":
+        case "not_in": {
+          const arr = Array.isArray(operand) ? operand : [operand];
+          if (arr.length === 0) {
+            parts.push(op === "in" ? "false" : "true");
+            break;
+          }
+          const ph = arr.map((v) => params.next(this.encodeOperand(col, v))).join(", ");
+          parts.push(`${id} ${op === "in" ? "IN" : "NOT IN"} (${ph})`);
+          break;
+        }
+        case "greater_than":
+          parts.push(`${id} > ${params.next(this.encodeOperand(col, operand))}`);
+          break;
+        case "greater_than_equal":
+          parts.push(`${id} >= ${params.next(this.encodeOperand(col, operand))}`);
+          break;
+        case "less_than":
+          parts.push(`${id} < ${params.next(this.encodeOperand(col, operand))}`);
+          break;
+        case "less_than_equal":
+          parts.push(`${id} <= ${params.next(this.encodeOperand(col, operand))}`);
+          break;
+        case "like":
+        case "contains": {
+          const literal = String(operand).replace(/[\\%_]/g, (ch) => `\\${ch}`);
+          parts.push(`${id}::text ILIKE ${params.next(`%${literal}%`)} ESCAPE '\\'`);
+          break;
+        }
+        case "exists":
+          parts.push(operand ? `${id} IS NOT NULL` : `${id} IS NULL`);
+          break;
+        default:
+          throw new Error(`Unsupported operator "${op}".`);
+      }
+    }
+    return parts.length ? `(${parts.join(" AND ")})` : "";
+  }
+  whereSql(table, where, params) {
+    if (!where) return "";
+    const clause = this.buildWhere(where, table, this.colByName(table), this.allowed(table.table), params);
+    return clause ? ` WHERE ${clause}` : "";
+  }
+  // -- CRUD (each takes the queryable so transactions reuse a bound client) --
+  async rawGet(q, table, id) {
+    const res = await q.query(`SELECT * FROM ${quote(table.table)} WHERE ${quote("id")} = $1`, [id]);
+    const row = res.rows[0];
+    return row ? this.decodeRow(table, row) : null;
+  }
+  async _findByID(q, args) {
+    return this.rawGet(q, this.table(args.collection), args.id);
+  }
+  async _find(q, args) {
+    const table = this.table(args.collection);
+    const allowed = this.allowed(table.table);
+    const countParams = new Params();
+    const whereForCount = this.whereSql(table, args.where, countParams);
+    const totalRes = await q.query(
+      `SELECT COUNT(*)::int AS c FROM ${quote(table.table)}${whereForCount}`,
+      countParams.values
+    );
+    const totalDocs = Number(totalRes.rows[0]?.c ?? 0);
+    const params = new Params();
+    const whereSql = this.whereSql(table, args.where, params);
+    const sortParts = (args.sort ?? []).filter((s) => allowed.has(s.field)).map((s) => `${quote(s.field)} ${s.direction === "desc" ? "DESC" : "ASC"}`);
+    const orderBy = sortParts.length ? ` ORDER BY ${sortParts.join(", ")}` : ` ORDER BY ${quote("id")} ASC`;
+    const limit = args.limit;
+    const offset = (args.page - 1) * limit;
+    const limitPh = params.next(limit);
+    const offsetPh = params.next(offset);
+    const res = await q.query(
+      `SELECT * FROM ${quote(table.table)}${whereSql}${orderBy} LIMIT ${limitPh} OFFSET ${offsetPh}`,
+      params.values
+    );
+    const docs = res.rows.map((r) => this.decodeRow(table, r));
+    const totalPages = limit > 0 ? Math.max(Math.ceil(totalDocs / limit), 1) : 1;
+    const page = args.page;
+    return {
+      docs,
+      totalDocs,
+      limit,
+      page,
+      totalPages,
+      hasPrevPage: page > 1,
+      hasNextPage: page < totalPages,
+      prevPage: page > 1 ? page - 1 : null,
+      nextPage: page < totalPages ? page + 1 : null,
+      pagingCounter: offset + 1
+    };
+  }
+  async _create(q, args) {
+    const table = this.table(args.collection);
+    const id = String(args.data.id);
+    const fields = [quote("id")];
+    const params = new Params();
+    const placeholders = [params.next(id)];
+    for (const col of table.columns) {
+      if (Object.prototype.hasOwnProperty.call(args.data, col.name)) {
+        fields.push(quote(col.name));
+        placeholders.push(params.next(this.encode(col, args.data[col.name])));
+      }
+    }
+    if (table.timestamps) {
+      fields.push(quote("createdAt"), quote("updatedAt"));
+      placeholders.push("now()", "now()");
+    }
+    const res = await q.query(
+      `INSERT INTO ${quote(table.table)} (${fields.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING *`,
+      params.values
+    );
+    const created = res.rows[0];
+    if (!created) throw new Error("Insert succeeded but returned no row.");
+    return this.decodeRow(table, created);
+  }
+  async _update(q, args) {
+    const table = this.table(args.collection);
+    const sets = [];
+    const params = new Params();
+    for (const col of table.columns) {
+      if (Object.prototype.hasOwnProperty.call(args.data, col.name)) {
+        sets.push(`${quote(col.name)} = ${params.next(this.encode(col, args.data[col.name]))}`);
+      }
+    }
+    if (table.timestamps) sets.push(`${quote("updatedAt")} = now()`);
+    if (sets.length === 0) return this.rawGet(q, table, args.id);
+    const idPh = params.next(args.id);
+    const res = await q.query(
+      `UPDATE ${quote(table.table)} SET ${sets.join(", ")} WHERE ${quote("id")} = ${idPh} RETURNING *`,
+      params.values
+    );
+    const row = res.rows[0];
+    return row ? this.decodeRow(table, row) : null;
+  }
+  async _delete(q, args) {
+    const table = this.table(args.collection);
+    const res = await q.query(`DELETE FROM ${quote(table.table)} WHERE ${quote("id")} = $1 RETURNING *`, [args.id]);
+    const row = res.rows[0];
+    return row ? this.decodeRow(table, row) : null;
+  }
+  async _count(q, args) {
+    const table = this.table(args.collection);
+    const params = new Params();
+    const whereSql = this.whereSql(table, args.where, params);
+    const res = await q.query(`SELECT COUNT(*)::int AS c FROM ${quote(table.table)}${whereSql}`, params.values);
+    return Number(res.rows[0]?.c ?? 0);
+  }
+  // -- public contract surface (pool-backed) --------------------------------
+  async findByID(args) {
+    return this._findByID(this.requirePool(), args);
+  }
+  async find(args) {
+    return this._find(this.requirePool(), args);
+  }
+  async create(args) {
+    return this._create(this.requirePool(), args);
+  }
+  async update(args) {
+    return this._update(this.requirePool(), args);
+  }
+  async delete(args) {
+    return this._delete(this.requirePool(), args);
+  }
+  async count(args) {
+    return this._count(this.requirePool(), args);
+  }
+  /** A transaction-scoped adapter bound to a single client (or savepoint). */
+  bound(client) {
+    const q = client;
+    return {
+      kind: this.kind,
+      name: this.name,
+      contractVersion: this.contractVersion,
+      capabilities: this.capabilities,
+      init: async () => {
+      },
+      migrate: () => {
+        throw new Error("migrate() is not available inside a transaction.");
+      },
+      find: (a) => this._find(q, a),
+      findByID: (a) => this._findByID(q, a),
+      create: (a) => this._create(q, a),
+      update: (a) => this._update(q, a),
+      delete: (a) => this._delete(q, a),
+      count: (a) => this._count(q, a),
+      transaction: (fn) => this.savepoint(client, fn),
+      health: async () => ({ status: "ok" }),
+      destroy: async () => {
+      }
+    };
+  }
+  async savepoint(client, fn) {
+    const name = `sp_${++this.savepointSeq}`;
+    await client.query(`SAVEPOINT ${name}`);
+    try {
+      const result = await fn(this.bound(client));
+      await client.query(`RELEASE SAVEPOINT ${name}`);
+      return result;
+    } catch (err) {
+      await client.query(`ROLLBACK TO SAVEPOINT ${name}`);
+      throw err;
+    }
+  }
+  async transaction(fn) {
+    const client = await this.requirePool().connect();
+    await client.query("BEGIN");
+    try {
+      const result = await fn(this.bound(client));
+      await client.query("COMMIT");
+      return result;
+    } catch (err) {
+      try {
+        await client.query("ROLLBACK");
+      } catch {
+      }
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  async health() {
+    try {
+      await this.requirePool().query("SELECT 1");
+      return { status: "ok" };
+    } catch (err) {
+      return { status: "down", detail: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async destroy() {
+    await this.pool?.end();
+    this.pool = null;
+  }
+};
+function postgresAdapter(options = {}) {
+  return new PostgresAdapter(options);
+}
+export {
+  postgresAdapter
+};

package/dist/server.d.ts

@@ -0,0 +1,27 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { g as AuthUser, K as Kernel } from './types-DMOX4FIP.js';
+import { W as Where } from './index-BxvPeUO2.js';
+
+interface HandlerOptions {
+    /** Shared secret; a request with `Authorization: Bearer <apiKey>` runs as a trusted system caller. */
+    apiKey?: string;
+    /** Resolve the authenticated user for a request (sessions, JWT, etc.). */
+    getUser?: (request: Request) => Promise<AuthUser | null> | AuthUser | null;
+    /** CORS: true reflects the request origin; an array allow-lists origins. */
+    cors?: boolean | string[];
+}
+type RequestHandler = (request: Request) => Promise<Response>;
+declare function createRequestHandler(kernel: Kernel, options?: HandlerOptions): RequestHandler;
+declare function parseWhere(params: URLSearchParams): Where | undefined;
+declare function toNodeListener(handler: RequestHandler): (req: IncomingMessage, res: ServerResponse) => void;
+interface ServeOptions extends HandlerOptions {
+    port?: number;
+}
+interface RunningServer {
+    url: string;
+    port: number;
+    close: () => Promise<void>;
+}
+declare function serve(kernel: Kernel, options?: ServeOptions): Promise<RunningServer>;
+
+export { type HandlerOptions, type RunningServer, type ServeOptions, createRequestHandler, parseWhere, serve, toNodeListener };

package/dist/server.js

@@ -0,0 +1,13 @@
+import {
+  createRequestHandler,
+  parseWhere,
+  serve,
+  toNodeListener
+} from "./chunk-Z2RKB4LF.js";
+import "./chunk-O5TO5JFA.js";
+export {
+  createRequestHandler,
+  parseWhere,
+  serve,
+  toNodeListener
+};

package/dist/sqlite.d.ts

@@ -0,0 +1,14 @@
+import { D as DatabaseAdapter } from './index-BxvPeUO2.js';
+
+interface SQLiteAdapterOptions {
+    /** File path or ':memory:'. Accepts "file:./x.db" URLs too. Default ':memory:'. */
+    url?: string;
+    /** Set busy timeout in ms. Default 5000. */
+    busyTimeout?: number;
+    /** Use WAL journal mode for file databases. Default true. */
+    wal?: boolean;
+}
+/** Create a SQLite database adapter. */
+declare function sqliteAdapter(options?: SQLiteAdapterOptions): DatabaseAdapter;
+
+export { type SQLiteAdapterOptions, sqliteAdapter };