@momentumcms/db-drizzle 0.1.0

package/index.cjs

@@ -0,0 +1,1886 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/db-drizzle/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  postgresAdapter: () => postgresAdapter,
+  sqliteAdapter: () => sqliteAdapter
+});
+module.exports = __toCommonJS(src_exports);
+
+// libs/db-drizzle/src/lib/db-drizzle.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// libs/core/src/lib/collections/define-collection.ts
+function defineCollection(config) {
+  const collection = {
+    timestamps: true,
+    // Enable timestamps by default
+    ...config
+  };
+  if (!collection.slug) {
+    throw new Error("Collection must have a slug");
+  }
+  if (!collection.fields || collection.fields.length === 0) {
+    throw new Error(`Collection "${collection.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(collection.slug)) {
+    throw new Error(
+      `Collection slug "${collection.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return collection;
+}
+function getSoftDeleteField(config) {
+  if (!config.softDelete)
+    return null;
+  if (config.softDelete === true)
+    return "deletedAt";
+  const sdConfig = config.softDelete;
+  return sdConfig.field ?? "deletedAt";
+}
+
+// libs/core/src/lib/fields/field.types.ts
+var ReferentialIntegrityError = class extends Error {
+  constructor(table, constraint) {
+    super(`Cannot delete from "${table}": referenced by foreign key constraint "${constraint}"`);
+    this.name = "ReferentialIntegrityError";
+    this.table = table;
+    this.constraint = constraint;
+  }
+};
+function flattenDataFields(fields) {
+  const result = [];
+  for (const field of fields) {
+    if (field.type === "tabs") {
+      for (const tab of field.tabs) {
+        result.push(...flattenDataFields(tab.fields));
+      }
+    } else if (field.type === "collapsible" || field.type === "row") {
+      result.push(...flattenDataFields(field.fields));
+    } else {
+      result.push(field);
+    }
+  }
+  return result;
+}
+
+// libs/core/src/lib/fields/field-builders.ts
+function text(name, options = {}) {
+  return {
+    name,
+    type: "text",
+    ...options
+  };
+}
+function number(name, options = {}) {
+  return {
+    name,
+    type: "number",
+    ...options
+  };
+}
+function json(name, options = {}) {
+  return {
+    name,
+    type: "json",
+    ...options
+  };
+}
+
+// libs/core/src/lib/collections/media.collection.ts
+var MediaCollection = defineCollection({
+  slug: "media",
+  labels: {
+    singular: "Media",
+    plural: "Media"
+  },
+  admin: {
+    useAsTitle: "filename",
+    defaultColumns: ["filename", "mimeType", "filesize", "createdAt"]
+  },
+  fields: [
+    text("filename", {
+      required: true,
+      label: "Filename",
+      description: "Original filename of the uploaded file"
+    }),
+    text("mimeType", {
+      required: true,
+      label: "MIME Type",
+      description: "File MIME type (e.g., image/jpeg, application/pdf)"
+    }),
+    number("filesize", {
+      label: "File Size",
+      description: "File size in bytes"
+    }),
+    text("path", {
+      required: true,
+      label: "Storage Path",
+      description: "Path/key where the file is stored",
+      admin: {
+        hidden: true
+      }
+    }),
+    text("url", {
+      label: "URL",
+      description: "Public URL to access the file"
+    }),
+    text("alt", {
+      label: "Alt Text",
+      description: "Alternative text for accessibility"
+    }),
+    number("width", {
+      label: "Width",
+      description: "Image width in pixels (for images only)"
+    }),
+    number("height", {
+      label: "Height",
+      description: "Image height in pixels (for images only)"
+    }),
+    json("focalPoint", {
+      label: "Focal Point",
+      description: "Focal point coordinates for image cropping",
+      admin: {
+        hidden: true
+      }
+    })
+  ],
+  access: {
+    // Media is readable by anyone by default
+    read: () => true,
+    // Only authenticated users can create/update/delete
+    create: ({ req }) => !!req?.user,
+    update: ({ req }) => !!req?.user,
+    delete: ({ req }) => !!req?.user
+  }
+});
+
+// libs/db-drizzle/src/lib/db-drizzle.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isDocumentStatus(value) {
+  return value === "draft" || value === "published";
+}
+function getStatusFromRow(row2) {
+  const status = row2["_status"];
+  if (isDocumentStatus(status)) {
+    return status;
+  }
+  return "draft";
+}
+function parseJsonToRecord(jsonString) {
+  try {
+    const parsed = JSON.parse(jsonString);
+    if (isRecord(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function validateCollectionSlug(slug2) {
+  const validSlug = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
+  if (!validSlug.test(slug2)) {
+    throw new Error(
+      `Invalid collection slug: "${slug2}". Slugs must start with a letter or underscore and contain only alphanumeric characters, underscores, and hyphens.`
+    );
+  }
+}
+function validateColumnName(name) {
+  const validColumnName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+  if (!validColumnName.test(name)) {
+    throw new Error(`Invalid column name: "${name}"`);
+  }
+}
+var AsyncQueue = class {
+  constructor() {
+    this.queue = Promise.resolve();
+  }
+  /**
+   * Add an operation to the queue. Operations execute sequentially.
+   */
+  enqueue(operation) {
+    const result = this.queue.then(() => operation());
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+};
+function getColumnType(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richText":
+    case "email":
+    case "slug":
+    case "select":
+      return "TEXT";
+    case "number":
+      return "REAL";
+    case "checkbox":
+      return "INTEGER";
+    case "date":
+      return "TEXT";
+    case "relationship":
+    case "upload":
+      return "TEXT";
+    case "array":
+    case "group":
+    case "blocks":
+    case "json":
+      return "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+function createTableSql(collection) {
+  const columns = [
+    "id TEXT PRIMARY KEY",
+    "createdAt TEXT NOT NULL",
+    "updatedAt TEXT NOT NULL"
+  ];
+  if (hasVersionDrafts(collection)) {
+    columns.push(`"_status" TEXT NOT NULL DEFAULT 'draft'`);
+  }
+  const softDeleteCol = getSoftDeleteField(collection);
+  if (softDeleteCol) {
+    validateColumnName(softDeleteCol);
+    columns.push(`"${softDeleteCol}" TEXT`);
+  }
+  const dataFields = flattenDataFields(collection.fields);
+  for (const field of dataFields) {
+    const colType = getColumnType(field);
+    const notNull = field.required ? " NOT NULL" : "";
+    columns.push(`"${field.name}" ${colType}${notNull}`);
+  }
+  const tableName = collection.dbName ?? collection.slug;
+  return `CREATE TABLE IF NOT EXISTS "${tableName}" (${columns.join(", ")})`;
+}
+function getTableName(collection) {
+  return collection.dbName ?? collection.slug;
+}
+function hasVersionDrafts(collection) {
+  const versions = collection.versions;
+  if (!versions)
+    return false;
+  if (typeof versions === "boolean")
+    return false;
+  return !!versions.drafts;
+}
+function createVersionTableSql(collection) {
+  if (!collection.versions) {
+    return null;
+  }
+  const baseTable = getTableName(collection);
+  const tableName = `${baseTable}_versions`;
+  return `
+		CREATE TABLE IF NOT EXISTS "${tableName}" (
+			"id" TEXT PRIMARY KEY NOT NULL,
+			"parent" TEXT NOT NULL,
+			"version" TEXT NOT NULL,
+			"_status" TEXT NOT NULL DEFAULT 'draft',
+			"autosave" INTEGER NOT NULL DEFAULT 0,
+			"publishedAt" TEXT,
+			"createdAt" TEXT NOT NULL,
+			"updatedAt" TEXT NOT NULL,
+			FOREIGN KEY ("parent") REFERENCES "${baseTable}"("id") ON DELETE CASCADE
+		);
+
+		CREATE INDEX IF NOT EXISTS "idx_${tableName}_parent" ON "${tableName}"("parent");
+		CREATE INDEX IF NOT EXISTS "idx_${tableName}_status" ON "${tableName}"("_status");
+		CREATE INDEX IF NOT EXISTS "idx_${tableName}_createdAt" ON "${tableName}"("createdAt");
+	`;
+}
+function ensureDirectoryExists(filePath) {
+  if (filePath === ":memory:") {
+    return;
+  }
+  const dir = (0, import_node_path.dirname)(filePath);
+  if (dir && dir !== "." && !(0, import_node_fs.existsSync)(dir)) {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  }
+}
+var SEED_TRACKING_TABLE_SQL = `
+	CREATE TABLE IF NOT EXISTS "_momentum_seeds" (
+		"id" TEXT PRIMARY KEY NOT NULL,
+		"seedId" TEXT NOT NULL UNIQUE,
+		"collection" TEXT NOT NULL,
+		"documentId" TEXT NOT NULL,
+		"checksum" TEXT NOT NULL,
+		"createdAt" TEXT NOT NULL,
+		"updatedAt" TEXT NOT NULL
+	);
+
+	CREATE INDEX IF NOT EXISTS "idx_momentum_seeds_seedId" ON "_momentum_seeds"("seedId");
+`;
+function sqliteAdapter(options) {
+  ensureDirectoryExists(options.filename);
+  const sqlite = new import_better_sqlite3.default(options.filename);
+  sqlite.pragma("journal_mode = WAL");
+  const writeQueue = new AsyncQueue();
+  const tableNameMap = /* @__PURE__ */ new Map();
+  function resolveTableName(slug2) {
+    return tableNameMap.get(slug2) ?? slug2;
+  }
+  function findSync(collection, query) {
+    validateCollectionSlug(collection);
+    const limitValue = typeof query["limit"] === "number" ? query["limit"] : 100;
+    const pageValue = typeof query["page"] === "number" ? query["page"] : 1;
+    const offset = (pageValue - 1) * limitValue;
+    const whereClauses = [];
+    const whereValues = [];
+    const reservedParams = /* @__PURE__ */ new Set(["limit", "page", "sort", "order"]);
+    const validColumnName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    for (const [key, value] of Object.entries(query)) {
+      if (reservedParams.has(key))
+        continue;
+      if (value === void 0)
+        continue;
+      if (!validColumnName.test(key)) {
+        throw new Error(`Invalid column name: ${key}`);
+      }
+      if (value === null) {
+        whereClauses.push(`"${key}" IS NULL`);
+      } else if (typeof value === "object" && value !== null && "$ne" in value && value["$ne"] === null) {
+        whereClauses.push(`"${key}" IS NOT NULL`);
+      } else {
+        whereClauses.push(`"${key}" = ?`);
+        whereValues.push(value);
+      }
+    }
+    const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    let rows;
+    if (limitValue === 0) {
+      const sql = `SELECT * FROM "${resolveTableName(collection)}" ${whereClause}`;
+      rows = sqlite.prepare(sql).all(...whereValues);
+    } else {
+      const sql = `SELECT * FROM "${resolveTableName(collection)}" ${whereClause} LIMIT ? OFFSET ?`;
+      rows = sqlite.prepare(sql).all(...whereValues, limitValue, offset);
+    }
+    return rows.filter(
+      (row2) => typeof row2 === "object" && row2 !== null
+    );
+  }
+  function findByIdSync(collection, id) {
+    validateCollectionSlug(collection);
+    const row2 = sqlite.prepare(`SELECT * FROM "${resolveTableName(collection)}" WHERE id = ?`).get(id);
+    return isRecord(row2) ? row2 : null;
+  }
+  function createSync(collection, data) {
+    validateCollectionSlug(collection);
+    const id = (0, import_node_crypto.randomUUID)();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const doc = { ...data, id, createdAt: now, updatedAt: now };
+    const columns = Object.keys(doc);
+    const placeholders = columns.map(() => "?").join(", ");
+    const values = columns.map((col) => {
+      const val = doc[col];
+      if (val === void 0)
+        return null;
+      if (typeof val === "boolean")
+        return val ? 1 : 0;
+      if (typeof val === "object" && val !== null)
+        return JSON.stringify(val);
+      return val;
+    });
+    const quotedColumns = columns.map((c) => `"${c}"`).join(", ");
+    sqlite.prepare(
+      `INSERT INTO "${resolveTableName(collection)}" (${quotedColumns}) VALUES (${placeholders})`
+    ).run(...values);
+    return doc;
+  }
+  function updateSync(collection, id, data) {
+    validateCollectionSlug(collection);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updateData = { ...data, updatedAt: now };
+    delete updateData["id"];
+    delete updateData["createdAt"];
+    const setClauses = [];
+    const values = [];
+    for (const [key, value] of Object.entries(updateData)) {
+      setClauses.push(`"${key}" = ?`);
+      if (value === void 0)
+        values.push(null);
+      else if (typeof value === "boolean")
+        values.push(value ? 1 : 0);
+      else if (typeof value === "object" && value !== null)
+        values.push(JSON.stringify(value));
+      else
+        values.push(value);
+    }
+    values.push(id);
+    sqlite.prepare(`UPDATE "${resolveTableName(collection)}" SET ${setClauses.join(", ")} WHERE id = ?`).run(...values);
+    const updated = sqlite.prepare(`SELECT * FROM "${resolveTableName(collection)}" WHERE id = ?`).get(id);
+    if (!isRecord(updated)) {
+      throw new Error("Failed to fetch updated document");
+    }
+    return updated;
+  }
+  function deleteSync(collection, id) {
+    validateCollectionSlug(collection);
+    const result = sqlite.prepare(`DELETE FROM "${resolveTableName(collection)}" WHERE id = ?`).run(id);
+    return result.changes > 0;
+  }
+  function softDeleteSync(collection, id, field = "deletedAt") {
+    validateCollectionSlug(collection);
+    validateColumnName(field);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = sqlite.prepare(
+      `UPDATE "${resolveTableName(collection)}" SET "${field}" = ?, "updatedAt" = ? WHERE "id" = ?`
+    ).run(now, now, id);
+    return result.changes > 0;
+  }
+  function restoreSync(collection, id, field = "deletedAt") {
+    validateCollectionSlug(collection);
+    validateColumnName(field);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    sqlite.prepare(
+      `UPDATE "${resolveTableName(collection)}" SET "${field}" = NULL, "updatedAt" = ? WHERE "id" = ?`
+    ).run(now, id);
+    const row2 = sqlite.prepare(`SELECT * FROM "${resolveTableName(collection)}" WHERE "id" = ?`).get(id);
+    if (!isRecord(row2)) {
+      throw new Error("Failed to fetch restored document");
+    }
+    return row2;
+  }
+  function createVersionSync(collection, parentId, data, options2) {
+    validateCollectionSlug(collection);
+    const id = (0, import_node_crypto.randomUUID)();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const tableName = `${resolveTableName(collection)}_versions`;
+    const status = options2?.status ?? "draft";
+    const autosave = options2?.autosave ? 1 : 0;
+    const doc = {
+      id,
+      parent: parentId,
+      version: JSON.stringify(data),
+      _status: status,
+      autosave: autosave === 1,
+      publishedAt: status === "published" ? now : void 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    sqlite.prepare(
+      `INSERT INTO "${tableName}" ("id", "parent", "version", "_status", "autosave", "publishedAt", "createdAt", "updatedAt")
+				 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      doc.id,
+      doc.parent,
+      doc.version,
+      doc._status,
+      autosave,
+      doc.publishedAt ?? null,
+      doc.createdAt,
+      doc.updatedAt
+    );
+    return doc;
+  }
+  function findVersionsSync(collection, parentId, options2) {
+    validateCollectionSlug(collection);
+    const tableName = `${resolveTableName(collection)}_versions`;
+    const limit = options2?.limit ?? 10;
+    const page = options2?.page ?? 1;
+    const offset = (page - 1) * limit;
+    const sortOrder = options2?.sort === "asc" ? "ASC" : "DESC";
+    const whereClauses = ['"parent" = ?'];
+    const whereValues = [parentId];
+    if (!options2?.includeAutosave)
+      whereClauses.push('"autosave" = 0');
+    if (options2?.status) {
+      whereClauses.push('"_status" = ?');
+      whereValues.push(options2.status);
+    }
+    const whereClause = whereClauses.join(" AND ");
+    const sql = `SELECT * FROM "${tableName}" WHERE ${whereClause} ORDER BY "createdAt" ${sortOrder} LIMIT ? OFFSET ?`;
+    const rows = sqlite.prepare(sql).all(...whereValues, limit, offset);
+    return rows.filter(isRecord).map((row2) => ({
+      id: String(row2["id"]),
+      parent: String(row2["parent"]),
+      version: String(row2["version"]),
+      _status: getStatusFromRow(row2),
+      autosave: row2["autosave"] === 1,
+      publishedAt: row2["publishedAt"] ? String(row2["publishedAt"]) : void 0,
+      createdAt: String(row2["createdAt"]),
+      updatedAt: String(row2["updatedAt"])
+    }));
+  }
+  function findVersionByIdSync(collection, versionId) {
+    validateCollectionSlug(collection);
+    const tableName = `${resolveTableName(collection)}_versions`;
+    const row2 = sqlite.prepare(`SELECT * FROM "${tableName}" WHERE "id" = ?`).get(versionId);
+    if (!isRecord(row2))
+      return null;
+    return {
+      id: String(row2["id"]),
+      parent: String(row2["parent"]),
+      version: String(row2["version"]),
+      _status: getStatusFromRow(row2),
+      autosave: row2["autosave"] === 1,
+      publishedAt: row2["publishedAt"] ? String(row2["publishedAt"]) : void 0,
+      createdAt: String(row2["createdAt"]),
+      updatedAt: String(row2["updatedAt"])
+    };
+  }
+  function restoreVersionSync(collection, versionId) {
+    validateCollectionSlug(collection);
+    const tableName = `${resolveTableName(collection)}_versions`;
+    const versionRow = sqlite.prepare(`SELECT * FROM "${tableName}" WHERE "id" = ?`).get(versionId);
+    if (!isRecord(versionRow)) {
+      throw new Error(
+        `Version "${versionId}" not found in collection "${resolveTableName(collection)}"`
+      );
+    }
+    const parentId = String(versionRow["parent"]);
+    const versionData = parseJsonToRecord(String(versionRow["version"]));
+    const originalStatus = getStatusFromRow(versionRow);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const setClauses = [];
+    const values = [];
+    const validColumnName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    for (const [key, value] of Object.entries(versionData)) {
+      if (key === "id" || key === "createdAt")
+        continue;
+      if (!validColumnName.test(key)) {
+        throw new Error(`Invalid column name in version data: ${key}`);
+      }
+      setClauses.push(`"${key}" = ?`);
+      if (value === void 0)
+        values.push(null);
+      else if (typeof value === "boolean")
+        values.push(value ? 1 : 0);
+      else if (typeof value === "object" && value !== null)
+        values.push(JSON.stringify(value));
+      else
+        values.push(value);
+    }
+    setClauses.push('"updatedAt" = ?');
+    values.push(now);
+    values.push(parentId);
+    sqlite.prepare(
+      `UPDATE "${resolveTableName(collection)}" SET ${setClauses.join(", ")} WHERE "id" = ?`
+    ).run(...values);
+    const newVersionId = (0, import_node_crypto.randomUUID)();
+    sqlite.prepare(
+      `INSERT INTO "${tableName}" ("id", "parent", "version", "_status", "autosave", "createdAt", "updatedAt")
+				 VALUES (?, ?, ?, ?, 0, ?, ?)`
+    ).run(newVersionId, parentId, String(versionRow["version"]), originalStatus, now, now);
+    const updated = sqlite.prepare(`SELECT * FROM "${resolveTableName(collection)}" WHERE "id" = ?`).get(parentId);
+    if (!isRecord(updated)) {
+      throw new Error("Failed to fetch restored document");
+    }
+    return updated;
+  }
+  function deleteVersionsSync(collection, parentId, keepLatest) {
+    validateCollectionSlug(collection);
+    const tableName = `${resolveTableName(collection)}_versions`;
+    if (keepLatest === void 0 || keepLatest <= 0) {
+      const result2 = sqlite.prepare(`DELETE FROM "${tableName}" WHERE "parent" = ?`).run(parentId);
+      return result2.changes;
+    }
+    const keepIds = sqlite.prepare(
+      `SELECT "id" FROM "${tableName}" WHERE "parent" = ? ORDER BY "createdAt" DESC LIMIT ?`
+    ).all(parentId, keepLatest).filter(isRecord).map((row2) => String(row2["id"]));
+    if (keepIds.length === 0)
+      return 0;
+    const placeholders = keepIds.map(() => "?").join(", ");
+    const result = sqlite.prepare(`DELETE FROM "${tableName}" WHERE "parent" = ? AND "id" NOT IN (${placeholders})`).run(parentId, ...keepIds);
+    return result.changes;
+  }
+  function countVersionsSync(collection, parentId, options2) {
+    validateCollectionSlug(collection);
+    const tableName = `${resolveTableName(collection)}_versions`;
+    const whereClauses = ['"parent" = ?'];
+    const whereValues = [parentId];
+    if (!options2?.includeAutosave)
+      whereClauses.push('"autosave" = 0');
+    if (options2?.status) {
+      whereClauses.push('"_status" = ?');
+      whereValues.push(options2.status);
+    }
+    const whereClause = whereClauses.join(" AND ");
+    const result = sqlite.prepare(`SELECT COUNT(*) as count FROM "${tableName}" WHERE ${whereClause}`).get(...whereValues);
+    if (isRecord(result) && typeof result["count"] === "number")
+      return result["count"];
+    return 0;
+  }
+  function updateStatusSync(collection, id, status) {
+    validateCollectionSlug(collection);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    sqlite.prepare(
+      `UPDATE "${resolveTableName(collection)}" SET "_status" = ?, "updatedAt" = ? WHERE "id" = ?`
+    ).run(status, now, id);
+  }
+  return {
+    getRawDatabase() {
+      return sqlite;
+    },
+    async initialize(collections) {
+      for (const collection of collections) {
+        const tbl = getTableName(collection);
+        tableNameMap.set(collection.slug, tbl);
+      }
+      sqlite.exec(SEED_TRACKING_TABLE_SQL);
+      for (const collection of collections) {
+        const tbl = getTableName(collection);
+        sqlite.exec(createTableSql(collection));
+        const versionTableSql = createVersionTableSql(collection);
+        if (versionTableSql)
+          sqlite.exec(versionTableSql);
+        const sdField = getSoftDeleteField(collection);
+        if (sdField) {
+          try {
+            sqlite.exec(`ALTER TABLE "${tbl}" ADD COLUMN "${sdField}" TEXT`);
+          } catch {
+          }
+          sqlite.exec(
+            `CREATE INDEX IF NOT EXISTS "idx_${tbl}_${sdField}" ON "${tbl}"("${sdField}")`
+          );
+        }
+        if (collection.indexes) {
+          for (const idx of collection.indexes) {
+            for (const col of idx.columns) {
+              validateColumnName(col);
+            }
+            const idxName = idx.name ?? `idx_${tbl}_${idx.columns.join("_")}`;
+            const uniqueStr = idx.unique ? "UNIQUE " : "";
+            const colList = idx.columns.map((c) => `"${c}"`).join(", ");
+            sqlite.exec(
+              `CREATE ${uniqueStr}INDEX IF NOT EXISTS "${idxName}" ON "${tbl}"(${colList})`
+            );
+          }
+        }
+      }
+    },
+    async find(collection, query) {
+      return findSync(collection, query);
+    },
+    async findById(collection, id) {
+      return findByIdSync(collection, id);
+    },
+    async create(collection, data) {
+      return writeQueue.enqueue(() => createSync(collection, data));
+    },
+    async update(collection, id, data) {
+      return writeQueue.enqueue(() => updateSync(collection, id, data));
+    },
+    async delete(collection, id) {
+      return writeQueue.enqueue(() => deleteSync(collection, id));
+    },
+    async softDelete(collection, id, field) {
+      return writeQueue.enqueue(() => softDeleteSync(collection, id, field));
+    },
+    async restore(collection, id, field) {
+      return writeQueue.enqueue(() => restoreSync(collection, id, field));
+    },
+    async createVersion(collection, parentId, data, options2) {
+      return writeQueue.enqueue(() => createVersionSync(collection, parentId, data, options2));
+    },
+    async findVersions(collection, parentId, options2) {
+      return findVersionsSync(collection, parentId, options2);
+    },
+    async findVersionById(collection, versionId) {
+      return findVersionByIdSync(collection, versionId);
+    },
+    async restoreVersion(collection, versionId) {
+      return writeQueue.enqueue(() => restoreVersionSync(collection, versionId));
+    },
+    async deleteVersions(collection, parentId, keepLatest) {
+      return writeQueue.enqueue(() => deleteVersionsSync(collection, parentId, keepLatest));
+    },
+    async countVersions(collection, parentId, options2) {
+      return countVersionsSync(collection, parentId, options2);
+    },
+    async updateStatus(collection, id, status) {
+      return writeQueue.enqueue(() => updateStatusSync(collection, id, status));
+    },
+    // ============================================
+    // Globals Support
+    // ============================================
+    async initializeGlobals(_globals) {
+      sqlite.exec(`
+				CREATE TABLE IF NOT EXISTS "_globals" (
+					"slug" TEXT PRIMARY KEY,
+					"data" TEXT NOT NULL DEFAULT '{}',
+					"createdAt" TEXT NOT NULL DEFAULT (datetime('now')),
+					"updatedAt" TEXT NOT NULL DEFAULT (datetime('now'))
+				)
+			`);
+    },
+    async findGlobal(slug2) {
+      const row2 = sqlite.prepare('SELECT * FROM "_globals" WHERE "slug" = ?').get(slug2);
+      if (!row2 || !isRecord(row2))
+        return null;
+      const data = JSON.parse(String(row2["data"]));
+      return {
+        ...data,
+        slug: row2["slug"],
+        createdAt: row2["createdAt"],
+        updatedAt: row2["updatedAt"]
+      };
+    },
+    async updateGlobal(slug2, data) {
+      return writeQueue.enqueue(() => {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const jsonData = JSON.stringify(data);
+        sqlite.prepare(
+          `
+					INSERT INTO "_globals" ("slug", "data", "createdAt", "updatedAt")
+					VALUES (?, ?, ?, ?)
+					ON CONFLICT ("slug") DO UPDATE SET "data" = excluded."data", "updatedAt" = excluded."updatedAt"
+				`
+        ).run(slug2, jsonData, now, now);
+        const row2 = sqlite.prepare('SELECT * FROM "_globals" WHERE "slug" = ?').get(slug2);
+        if (!row2 || !isRecord(row2)) {
+          return { slug: slug2, ...data, createdAt: now, updatedAt: now };
+        }
+        const returned = JSON.parse(String(row2["data"]));
+        return {
+          ...returned,
+          slug: row2["slug"],
+          createdAt: row2["createdAt"],
+          updatedAt: row2["updatedAt"]
+        };
+      });
+    },
+    async transaction(callback) {
+      return writeQueue.enqueue(async () => {
+        sqlite.exec("BEGIN IMMEDIATE");
+        try {
+          const txAdapter = {
+            async find(c, q) {
+              return findSync(c, q);
+            },
+            async findById(c, id) {
+              return findByIdSync(c, id);
+            },
+            async create(c, d) {
+              return createSync(c, d);
+            },
+            async update(c, id, d) {
+              return updateSync(c, id, d);
+            },
+            async delete(c, id) {
+              return deleteSync(c, id);
+            },
+            async softDelete(c, id, f) {
+              return softDeleteSync(c, id, f);
+            },
+            async restore(c, id, f) {
+              return restoreSync(c, id, f);
+            },
+            async createVersion(c, pid, d, o) {
+              return createVersionSync(c, pid, d, o);
+            },
+            async findVersions(c, pid, o) {
+              return findVersionsSync(c, pid, o);
+            },
+            async findVersionById(c, vid) {
+              return findVersionByIdSync(c, vid);
+            },
+            async restoreVersion(c, vid) {
+              return restoreVersionSync(c, vid);
+            },
+            async deleteVersions(c, pid, k) {
+              return deleteVersionsSync(c, pid, k);
+            },
+            async countVersions(c, pid, o) {
+              return countVersionsSync(c, pid, o);
+            },
+            async updateStatus(c, id, s) {
+              updateStatusSync(c, id, s);
+            }
+          };
+          const result = await callback(txAdapter);
+          sqlite.exec("COMMIT");
+          return result;
+        } catch (error) {
+          sqlite.exec("ROLLBACK");
+          throw error;
+        }
+      });
+    }
+  };
+}
+
+// libs/db-drizzle/src/lib/db-postgres.ts
+var import_pg = require("pg");
+var import_node_crypto2 = require("node:crypto");
+
+// libs/logger/src/lib/log-level.ts
+var LOG_LEVEL_VALUES = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4,
+  silent: 5
+};
+function shouldLog(messageLevel, configuredLevel) {
+  return LOG_LEVEL_VALUES[messageLevel] >= LOG_LEVEL_VALUES[configuredLevel];
+}
+
+// libs/logger/src/lib/ansi-colors.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Foreground colors
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m"
+};
+function colorize(text2, ...codes) {
+  if (codes.length === 0)
+    return text2;
+  return `${codes.join("")}${text2}${ANSI.reset}`;
+}
+function supportsColor() {
+  if (process.env["FORCE_COLOR"] === "1")
+    return true;
+  if (process.env["NO_COLOR"] !== void 0)
+    return false;
+  if (process.env["TERM"] === "dumb")
+    return false;
+  return process.stdout.isTTY === true;
+}
+
+// libs/logger/src/lib/formatters.ts
+var LEVEL_COLORS = {
+  debug: [ANSI.dim, ANSI.gray],
+  info: [ANSI.cyan],
+  warn: [ANSI.yellow],
+  error: [ANSI.red],
+  fatal: [ANSI.bold, ANSI.white, ANSI.bgRed]
+};
+function padLevel(level) {
+  return level.toUpperCase().padEnd(5);
+}
+function formatTimestamp(date2) {
+  const y = date2.getFullYear();
+  const mo = String(date2.getMonth() + 1).padStart(2, "0");
+  const d = String(date2.getDate()).padStart(2, "0");
+  const h = String(date2.getHours()).padStart(2, "0");
+  const mi = String(date2.getMinutes()).padStart(2, "0");
+  const s = String(date2.getSeconds()).padStart(2, "0");
+  const ms = String(date2.getMilliseconds()).padStart(3, "0");
+  return `${y}-${mo}-${d} ${h}:${mi}:${s}.${ms}`;
+}
+function formatData(data) {
+  const entries = Object.entries(data);
+  if (entries.length === 0)
+    return "";
+  return " " + entries.map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+}
+function prettyFormatter(entry) {
+  const useColor = supportsColor();
+  const level = entry.level;
+  const ts = formatTimestamp(entry.timestamp);
+  const levelStr = padLevel(entry.level);
+  const ctx = `[${entry.context}]`;
+  const msg = entry.message;
+  const enrichmentStr = entry.enrichments ? formatData(entry.enrichments) : "";
+  const dataStr = entry.data ? formatData(entry.data) : "";
+  const extra = `${enrichmentStr}${dataStr}`;
+  if (useColor) {
+    const colors = LEVEL_COLORS[level];
+    const coloredLevel = colorize(levelStr, ...colors);
+    const coloredCtx = colorize(ctx, ANSI.magenta);
+    const coloredTs = colorize(ts, ANSI.gray);
+    return `${coloredTs} ${coloredLevel} ${coloredCtx} ${msg}${extra}
+`;
+  }
+  return `${ts} ${levelStr} ${ctx} ${msg}${extra}
+`;
+}
+function jsonFormatter(entry) {
+  const output = {
+    timestamp: entry.timestamp.toISOString(),
+    level: entry.level,
+    context: entry.context,
+    message: entry.message
+  };
+  if (entry.enrichments && Object.keys(entry.enrichments).length > 0) {
+    Object.assign(output, entry.enrichments);
+  }
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    output["data"] = entry.data;
+  }
+  return JSON.stringify(output) + "\n";
+}
+
+// libs/logger/src/lib/logger-config.types.ts
+function resolveLoggingConfig(config) {
+  return {
+    level: config?.level ?? "info",
+    format: config?.format ?? "pretty",
+    timestamps: config?.timestamps ?? true,
+    output: config?.output ?? ((msg) => {
+      process.stdout.write(msg);
+    }),
+    errorOutput: config?.errorOutput ?? ((msg) => {
+      process.stderr.write(msg);
+    })
+  };
+}
+
+// libs/logger/src/lib/logger.ts
+var ERROR_LEVELS = /* @__PURE__ */ new Set(["warn", "error", "fatal"]);
+var MomentumLogger = class _MomentumLogger {
+  static {
+    this.enrichers = [];
+  }
+  constructor(context, config) {
+    this.context = context;
+    this.config = isResolvedConfig(config) ? config : resolveLoggingConfig(config);
+    this.formatter = this.config.format === "json" ? jsonFormatter : prettyFormatter;
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  fatal(message, data) {
+    this.log("fatal", message, data);
+  }
+  /**
+   * Creates a child logger with a sub-context.
+   * e.g., `Momentum:DB` → `Momentum:DB:Migrate`
+   */
+  child(subContext) {
+    return new _MomentumLogger(`${this.context}:${subContext}`, this.config);
+  }
+  /**
+   * Registers a global enricher that adds extra fields to all log entries.
+   */
+  static registerEnricher(enricher) {
+    _MomentumLogger.enrichers.push(enricher);
+  }
+  /**
+   * Removes a previously registered enricher.
+   */
+  static removeEnricher(enricher) {
+    const index = _MomentumLogger.enrichers.indexOf(enricher);
+    if (index >= 0) {
+      _MomentumLogger.enrichers.splice(index, 1);
+    }
+  }
+  /**
+   * Clears all registered enrichers. Primarily for testing.
+   */
+  static clearEnrichers() {
+    _MomentumLogger.enrichers.length = 0;
+  }
+  log(level, message, data) {
+    if (!shouldLog(level, this.config.level))
+      return;
+    const enrichments = this.collectEnrichments();
+    const entry = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      context: this.context,
+      message,
+      data,
+      enrichments: Object.keys(enrichments).length > 0 ? enrichments : void 0
+    };
+    const formatted = this.formatter(entry);
+    if (ERROR_LEVELS.has(level)) {
+      this.config.errorOutput(formatted);
+    } else {
+      this.config.output(formatted);
+    }
+  }
+  collectEnrichments() {
+    const result = {};
+    for (const enricher of _MomentumLogger.enrichers) {
+      Object.assign(result, enricher.enrich());
+    }
+    return result;
+  }
+};
+function isResolvedConfig(config) {
+  if (!config)
+    return false;
+  return typeof config.level === "string" && typeof config.format === "string" && typeof config.timestamps === "boolean" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- type guard narrows union
+  typeof config.output === "function" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- type guard narrows union
+  typeof config.errorOutput === "function";
+}
+
+// libs/logger/src/lib/logger-singleton.ts
+var loggerInstance = null;
+var ROOT_CONTEXT = "Momentum";
+function getMomentumLogger() {
+  if (!loggerInstance) {
+    loggerInstance = new MomentumLogger(ROOT_CONTEXT);
+  }
+  return loggerInstance;
+}
+function createLogger(context) {
+  return getMomentumLogger().child(context);
+}
+
+// libs/db-drizzle/src/lib/db-postgres.ts
+function getColumnType2(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richText":
+    case "password":
+    case "radio":
+    case "point":
+      return "TEXT";
+    case "email":
+    case "slug":
+    case "select":
+      return "VARCHAR(255)";
+    case "number":
+      return "NUMERIC";
+    case "checkbox":
+      return "BOOLEAN";
+    case "date":
+      return "TIMESTAMPTZ";
+    case "relationship":
+    case "upload":
+      return "VARCHAR(36)";
+    case "array":
+    case "group":
+    case "blocks":
+    case "json":
+      return "JSONB";
+    case "tabs":
+    case "collapsible":
+    case "row":
+      return "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+function resolveRelationshipSlug(field) {
+  try {
+    const config = field.collection();
+    if (config && typeof config === "object" && "slug" in config) {
+      const { slug: slug2 } = config;
+      if (typeof slug2 === "string")
+        return slug2;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function mapOnDelete(onDelete, required) {
+  const effective = required && (!onDelete || onDelete === "set-null") ? "restrict" : onDelete;
+  switch (effective) {
+    case "restrict":
+      return "ON DELETE RESTRICT";
+    case "cascade":
+      return "ON DELETE CASCADE";
+    default:
+      return "ON DELETE SET NULL";
+  }
+}
+function rethrowIfFkViolation(error, table) {
+  if (error instanceof Error && "code" in error && "constraint" in error) {
+    const { code, constraint } = error;
+    if (code === "23503") {
+      throw new ReferentialIntegrityError(table, constraint);
+    }
+  }
+}
+function createTableSql2(collection) {
+  const columns = [
+    '"id" VARCHAR(36) PRIMARY KEY',
+    '"createdAt" TIMESTAMPTZ NOT NULL',
+    '"updatedAt" TIMESTAMPTZ NOT NULL'
+  ];
+  if (hasVersionDrafts2(collection)) {
+    columns.push(`"_status" VARCHAR(20) DEFAULT 'draft'`);
+    columns.push('"scheduledPublishAt" TIMESTAMPTZ');
+  }
+  const softDeleteCol = getSoftDeleteField(collection);
+  if (softDeleteCol) {
+    validateColumnName2(softDeleteCol);
+    columns.push(`"${softDeleteCol}" TIMESTAMPTZ`);
+  }
+  const dataFields = flattenDataFields(collection.fields);
+  for (const field of dataFields) {
+    const colType = getColumnType2(field);
+    const notNull = field.required ? " NOT NULL" : "";
+    columns.push(`"${field.name}" ${colType}${notNull}`);
+  }
+  const tableName = collection.dbName ?? collection.slug;
+  return `CREATE TABLE IF NOT EXISTS "${tableName}" (${columns.join(", ")})`;
+}
+function getTableName2(collection) {
+  return collection.dbName ?? collection.slug;
+}
+function hasVersionDrafts2(collection) {
+  const versions = collection.versions;
+  if (!versions)
+    return false;
+  if (typeof versions === "boolean")
+    return false;
+  return !!versions.drafts;
+}
+function validateCollectionSlug2(slug2) {
+  const validSlug = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
+  if (!validSlug.test(slug2)) {
+    throw new Error(
+      `Invalid collection slug: "${slug2}". Slugs must start with a letter or underscore and contain only alphanumeric characters, underscores, and hyphens.`
+    );
+  }
+}
+function validateColumnName2(name) {
+  const validColumnName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+  if (!validColumnName.test(name)) {
+    throw new Error(`Invalid column name: "${name}"`);
+  }
+}
+function createVersionTableSql2(collection) {
+  if (!collection.versions)
+    return null;
+  const baseTable = getTableName2(collection);
+  const tableName = `${baseTable}_versions`;
+  return `
+		CREATE TABLE IF NOT EXISTS "${tableName}" (
+			"id" VARCHAR(36) PRIMARY KEY,
+			"parent" VARCHAR(36) NOT NULL,
+			"version" TEXT NOT NULL,
+			"_status" VARCHAR(20) DEFAULT 'draft',
+			"autosave" BOOLEAN DEFAULT false,
+			"publishedAt" TIMESTAMPTZ,
+			"createdAt" TIMESTAMPTZ NOT NULL,
+			"updatedAt" TIMESTAMPTZ NOT NULL,
+			CONSTRAINT "fk_${tableName}_parent" FOREIGN KEY ("parent") REFERENCES "${baseTable}"("id") ON DELETE CASCADE
+		);
+		CREATE INDEX IF NOT EXISTS "idx_${tableName}_parent" ON "${tableName}"("parent");
+		CREATE INDEX IF NOT EXISTS "idx_${tableName}_createdAt" ON "${tableName}"("createdAt");
+	`;
+}
+function isDocumentStatus2(value) {
+  return value === "draft" || value === "published";
+}
+function getStatusFromRow2(row2) {
+  const status = row2["_status"];
+  return isDocumentStatus2(status) ? status : "draft";
+}
+function parseJsonToRecord2(jsonString) {
+  try {
+    const parsed = JSON.parse(jsonString);
+    if (typeof parsed === "object" && parsed !== null) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+var SEED_TRACKING_TABLE_SQL2 = `
+	CREATE TABLE IF NOT EXISTS "_momentum_seeds" (
+		"id" VARCHAR(36) PRIMARY KEY NOT NULL,
+		"seedId" VARCHAR(255) NOT NULL UNIQUE,
+		"collection" VARCHAR(255) NOT NULL,
+		"documentId" VARCHAR(36) NOT NULL,
+		"checksum" VARCHAR(64) NOT NULL,
+		"createdAt" TIMESTAMPTZ NOT NULL,
+		"updatedAt" TIMESTAMPTZ NOT NULL
+	);
+
+	CREATE INDEX IF NOT EXISTS "idx_momentum_seeds_seedId" ON "_momentum_seeds"("seedId");
+`;
+function extractDatabaseName(connectionString) {
+  try {
+    const url = new URL(connectionString);
+    const dbName = url.pathname.slice(1);
+    return dbName || null;
+  } catch {
+    const match = connectionString.match(/\/([^/?]+)(\?|$)/);
+    return match?.[1] ?? null;
+  }
+}
+async function ensureDatabaseExists(connectionString) {
+  const dbName = extractDatabaseName(connectionString);
+  if (!dbName) {
+    return;
+  }
+  const testClient = new import_pg.Client({ connectionString });
+  try {
+    await testClient.connect();
+    await testClient.end();
+    return;
+  } catch (error) {
+    await testClient.end().catch(() => {
+    });
+    const pgError = error instanceof Object && "code" in error ? error : null;
+    if (!pgError || pgError.code !== "3D000") {
+      throw error;
+    }
+  }
+  let adminConnString;
+  try {
+    const url = new URL(connectionString);
+    url.pathname = "/postgres";
+    adminConnString = url.toString();
+  } catch {
+    adminConnString = connectionString.replace(`/${dbName}`, "/postgres");
+  }
+  const adminClient = new import_pg.Client({ connectionString: adminConnString });
+  try {
+    await adminClient.connect();
+    const safeName = dbName.replace(/"/g, '""');
+    await adminClient.query(`CREATE DATABASE "${safeName}"`);
+    createLogger("DB").info(`Created database "${dbName}"`);
+  } catch (createError) {
+    const pgCreateError = createError instanceof Object && "code" in createError ? createError : null;
+    if (pgCreateError && pgCreateError.code === "42P04") {
+      return;
+    }
+    throw createError;
+  } finally {
+    await adminClient.end();
+  }
+}
+function postgresAdapter(options) {
+  const pool = new import_pg.Pool({
+    connectionString: options.connectionString,
+    max: options.max ?? 10
+  });
+  const tableNameMap = /* @__PURE__ */ new Map();
+  function resolveTableName(slug2) {
+    return tableNameMap.get(slug2) ?? slug2;
+  }
+  function createHelpers(conn) {
+    async function query(sql, params = []) {
+      const result = await conn.query(sql, params);
+      return result.rows.filter((row2) => typeof row2 === "object" && row2 !== null);
+    }
+    async function queryOne(sql, params = []) {
+      const rows = await query(sql, params);
+      return rows[0] ?? null;
+    }
+    async function execute(sql, params = []) {
+      const result = await conn.query(sql, params);
+      return result.rowCount ?? 0;
+    }
+    return { query, queryOne, execute };
+  }
+  function buildMethods(h) {
+    return {
+      async find(collection, queryParams) {
+        validateCollectionSlug2(collection);
+        const limitValue = typeof queryParams["limit"] === "number" ? queryParams["limit"] : 100;
+        const pageValue = typeof queryParams["page"] === "number" ? queryParams["page"] : 1;
+        const offset = (pageValue - 1) * limitValue;
+        const whereClauses = [];
+        const whereValues = [];
+        const reservedParams = /* @__PURE__ */ new Set(["limit", "page", "sort", "order"]);
+        let paramIndex = 1;
+        const validColumnName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+        for (const [key, value] of Object.entries(queryParams)) {
+          if (reservedParams.has(key)) {
+            continue;
+          }
+          if (value === void 0)
+            continue;
+          if (!validColumnName.test(key)) {
+            throw new Error(`Invalid column name: ${key}`);
+          }
+          if (value === null) {
+            whereClauses.push(`"${key}" IS NULL`);
+          } else if (typeof value === "object" && value !== null && "$ne" in value && value["$ne"] === null) {
+            whereClauses.push(`"${key}" IS NOT NULL`);
+          } else {
+            whereClauses.push(`"${key}" = $${paramIndex}`);
+            whereValues.push(value);
+            paramIndex++;
+          }
+        }
+        const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+        if (limitValue === 0) {
+          return h.query(
+            `SELECT * FROM "${resolveTableName(collection)}" ${whereClause}`,
+            whereValues
+          );
+        }
+        return h.query(
+          `SELECT * FROM "${resolveTableName(collection)}" ${whereClause} LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+          [...whereValues, limitValue, offset]
+        );
+      },
+      async search(collection, searchQuery, fields, options2) {
+        validateCollectionSlug2(collection);
+        if (!searchQuery || fields.length === 0)
+          return [];
+        const limitValue = options2?.limit ?? 20;
+        const pageValue = options2?.page ?? 1;
+        const offset = (pageValue - 1) * limitValue;
+        const validColumnName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+        for (const field of fields) {
+          if (!validColumnName.test(field)) {
+            throw new Error(`Invalid column name: ${field}`);
+          }
+        }
+        const tsvectorParts = fields.map((f) => `coalesce("${f}"::text, '')`).join(" || ' ' || ");
+        const tsvectorExpr = `to_tsvector('simple', ${tsvectorParts})`;
+        const tsqueryExpr = `plainto_tsquery('simple', $1)`;
+        const ilikeClauses = fields.map((f, i) => `"${f}"::text ILIKE $${i + 2}`).join(" OR ");
+        const escapedQuery = searchQuery.replace(/[%_\\]/g, "\\$&");
+        const ilikePattern = `%${escapedQuery}%`;
+        const ilikeParams = fields.map(() => ilikePattern);
+        const sql = `
+					SELECT *, ts_rank(${tsvectorExpr}, ${tsqueryExpr}) AS _search_rank
+					FROM "${resolveTableName(collection)}"
+					WHERE ${tsvectorExpr} @@ ${tsqueryExpr} OR ${ilikeClauses}
+					ORDER BY _search_rank DESC
+					LIMIT $${fields.length + 2} OFFSET $${fields.length + 3}
+				`;
+        const results = await h.query(sql, [searchQuery, ...ilikeParams, limitValue, offset]);
+        return results.map((row2) => {
+          const { _search_rank, ...doc } = row2;
+          return doc;
+        });
+      },
+      async findById(collection, id) {
+        validateCollectionSlug2(collection);
+        return h.queryOne(`SELECT * FROM "${resolveTableName(collection)}" WHERE id = $1`, [id]);
+      },
+      async create(collection, data) {
+        validateCollectionSlug2(collection);
+        const id = (0, import_node_crypto2.randomUUID)();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const doc = {
+          ...data,
+          id,
+          createdAt: now,
+          updatedAt: now
+        };
+        const columns = Object.keys(doc);
+        const placeholders = columns.map((_, i) => `$${i + 1}`).join(", ");
+        const values = columns.map((col) => {
+          const val = doc[col];
+          if (val === void 0) {
+            return null;
+          }
+          if (typeof val === "object" && val !== null && !(val instanceof Date)) {
+            return JSON.stringify(val);
+          }
+          return val;
+        });
+        const quotedColumns = columns.map((c) => `"${c}"`).join(", ");
+        await h.execute(
+          `INSERT INTO "${resolveTableName(collection)}" (${quotedColumns}) VALUES (${placeholders})`,
+          values
+        );
+        return doc;
+      },
+      async update(collection, id, data) {
+        validateCollectionSlug2(collection);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const updateData = { ...data, updatedAt: now };
+        delete updateData["id"];
+        delete updateData["createdAt"];
+        const setClauses = [];
+        const values = [];
+        let paramIndex = 1;
+        for (const [key, value] of Object.entries(updateData)) {
+          setClauses.push(`"${key}" = $${paramIndex}`);
+          paramIndex++;
+          if (value === void 0) {
+            values.push(null);
+          } else if (typeof value === "object" && value !== null && !(value instanceof Date)) {
+            values.push(JSON.stringify(value));
+          } else {
+            values.push(value);
+          }
+        }
+        values.push(id);
+        await h.execute(
+          `UPDATE "${resolveTableName(collection)}" SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`,
+          values
+        );
+        const updated = await h.queryOne(
+          `SELECT * FROM "${resolveTableName(collection)}" WHERE id = $1`,
+          [id]
+        );
+        if (!updated) {
+          throw new Error("Failed to fetch updated document");
+        }
+        return updated;
+      },
+      async delete(collection, id) {
+        validateCollectionSlug2(collection);
+        try {
+          const rowCount = await h.execute(
+            `DELETE FROM "${resolveTableName(collection)}" WHERE id = $1`,
+            [id]
+          );
+          return rowCount > 0;
+        } catch (error) {
+          rethrowIfFkViolation(error, collection);
+          throw error;
+        }
+      },
+      async softDelete(collection, id, field = "deletedAt") {
+        validateCollectionSlug2(collection);
+        validateColumnName2(field);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const rowCount = await h.execute(
+          `UPDATE "${resolveTableName(collection)}" SET "${field}" = $1, "updatedAt" = $2 WHERE "id" = $3`,
+          [now, now, id]
+        );
+        return rowCount > 0;
+      },
+      async restore(collection, id, field = "deletedAt") {
+        validateCollectionSlug2(collection);
+        validateColumnName2(field);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        await h.execute(
+          `UPDATE "${resolveTableName(collection)}" SET "${field}" = NULL, "updatedAt" = $1 WHERE "id" = $2`,
+          [now, id]
+        );
+        const restored = await h.queryOne(
+          `SELECT * FROM "${resolveTableName(collection)}" WHERE "id" = $1`,
+          [id]
+        );
+        if (!restored) {
+          throw new Error("Failed to fetch restored document");
+        }
+        return restored;
+      },
+      // ==========================================
+      // Version Operations
+      // ==========================================
+      async createVersion(collection, parentId, data, options2) {
+        validateCollectionSlug2(collection);
+        const id = (0, import_node_crypto2.randomUUID)();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const status = options2?.status ?? "draft";
+        const autosave = options2?.autosave ?? false;
+        const publishedAt = status === "published" ? now : null;
+        const versionData = JSON.stringify(data);
+        const tableName = `${resolveTableName(collection)}_versions`;
+        await h.execute(
+          `INSERT INTO "${tableName}" ("id", "parent", "version", "_status", "autosave", "publishedAt", "createdAt", "updatedAt")
+					 VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+          [id, parentId, versionData, status, autosave, publishedAt, now, now]
+        );
+        return {
+          id,
+          parent: parentId,
+          version: versionData,
+          _status: status,
+          autosave,
+          publishedAt: publishedAt ?? void 0,
+          createdAt: now,
+          updatedAt: now
+        };
+      },
+      async findVersions(collection, parentId, options2) {
+        validateCollectionSlug2(collection);
+        const tableName = `${resolveTableName(collection)}_versions`;
+        const limit = options2?.limit ?? 10;
+        const page = options2?.page ?? 1;
+        const offset = (page - 1) * limit;
+        const sortDirection = options2?.sort === "asc" ? "ASC" : "DESC";
+        const whereClauses = ['"parent" = $1'];
+        const params = [parentId];
+        let paramIndex = 2;
+        if (!options2?.includeAutosave) {
+          whereClauses.push('"autosave" = false');
+        }
+        if (options2?.status) {
+          whereClauses.push(`"_status" = $${paramIndex}`);
+          params.push(options2.status);
+          paramIndex++;
+        }
+        const whereClause = whereClauses.join(" AND ");
+        params.push(limit, offset);
+        const rows = await h.query(
+          `SELECT * FROM "${tableName}" WHERE ${whereClause} ORDER BY "createdAt" ${sortDirection} LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+          params
+        );
+        return rows.map((row2) => ({
+          id: String(row2["id"]),
+          parent: String(row2["parent"]),
+          version: String(row2["version"]),
+          _status: getStatusFromRow2(row2),
+          autosave: Boolean(row2["autosave"]),
+          publishedAt: row2["publishedAt"] ? String(row2["publishedAt"]) : void 0,
+          createdAt: String(row2["createdAt"]),
+          updatedAt: String(row2["updatedAt"])
+        }));
+      },
+      async findVersionById(collection, versionId) {
+        validateCollectionSlug2(collection);
+        const tableName = `${resolveTableName(collection)}_versions`;
+        const row2 = await h.queryOne(
+          `SELECT * FROM "${tableName}" WHERE "id" = $1`,
+          [versionId]
+        );
+        if (!row2)
+          return null;
+        return {
+          id: String(row2["id"]),
+          parent: String(row2["parent"]),
+          version: String(row2["version"]),
+          _status: getStatusFromRow2(row2),
+          autosave: Boolean(row2["autosave"]),
+          publishedAt: row2["publishedAt"] ? String(row2["publishedAt"]) : void 0,
+          createdAt: String(row2["createdAt"]),
+          updatedAt: String(row2["updatedAt"])
+        };
+      },
+      async restoreVersion(collection, versionId) {
+        validateCollectionSlug2(collection);
+        const tableName = `${resolveTableName(collection)}_versions`;
+        const version = await h.queryOne(
+          `SELECT * FROM "${tableName}" WHERE "id" = $1`,
+          [versionId]
+        );
+        if (!version) {
+          throw new Error("Version not found");
+        }
+        const parentId = String(version["parent"]);
+        const versionData = parseJsonToRecord2(String(version["version"]));
+        const originalStatus = getStatusFromRow2(version);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const updateData = { ...versionData, updatedAt: now };
+        delete updateData["id"];
+        delete updateData["createdAt"];
+        const setClauses = [];
+        const values = [];
+        let paramIndex = 1;
+        const validColumnName = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+        for (const [key, value] of Object.entries(updateData)) {
+          if (!validColumnName.test(key)) {
+            throw new Error(`Invalid column name in version data: ${key}`);
+          }
+          setClauses.push(`"${key}" = $${paramIndex}`);
+          paramIndex++;
+          if (value === void 0) {
+            values.push(null);
+          } else if (typeof value === "object" && value !== null && !(value instanceof Date)) {
+            values.push(JSON.stringify(value));
+          } else {
+            values.push(value);
+          }
+        }
+        values.push(parentId);
+        await h.execute(
+          `UPDATE "${resolveTableName(collection)}" SET ${setClauses.join(", ")} WHERE "id" = $${paramIndex}`,
+          values
+        );
+        const newVersionId = (0, import_node_crypto2.randomUUID)();
+        await h.execute(
+          `INSERT INTO "${tableName}" ("id", "parent", "version", "_status", "autosave", "createdAt", "updatedAt")
+					 VALUES ($1, $2, $3, $4, false, $5, $6)`,
+          [newVersionId, parentId, String(version["version"]), originalStatus, now, now]
+        );
+        const updated = await h.queryOne(
+          `SELECT * FROM "${resolveTableName(collection)}" WHERE "id" = $1`,
+          [parentId]
+        );
+        if (!updated) {
+          throw new Error("Failed to fetch restored document");
+        }
+        return updated;
+      },
+      async deleteVersions(collection, parentId, keepLatest) {
+        validateCollectionSlug2(collection);
+        const tableName = `${resolveTableName(collection)}_versions`;
+        if (keepLatest && keepLatest > 0) {
+          const toKeep = await h.query(
+            `SELECT "id" FROM "${tableName}" WHERE "parent" = $1 ORDER BY "createdAt" DESC LIMIT $2`,
+            [parentId, keepLatest]
+          );
+          const keepIds = toKeep.map((r) => String(r["id"]));
+          if (keepIds.length === 0) {
+            return 0;
+          }
+          const placeholders = keepIds.map((_, i) => `$${i + 2}`).join(", ");
+          return h.execute(
+            `DELETE FROM "${tableName}" WHERE "parent" = $1 AND "id" NOT IN (${placeholders})`,
+            [parentId, ...keepIds]
+          );
+        }
+        return h.execute(`DELETE FROM "${tableName}" WHERE "parent" = $1`, [parentId]);
+      },
+      async countVersions(collection, parentId, options2) {
+        validateCollectionSlug2(collection);
+        const tableName = `${resolveTableName(collection)}_versions`;
+        const whereClauses = ['"parent" = $1'];
+        const params = [parentId];
+        if (!options2?.includeAutosave) {
+          whereClauses.push('"autosave" = false');
+        }
+        if (options2?.status) {
+          whereClauses.push(`"_status" = $${params.length + 1}`);
+          params.push(options2.status);
+        }
+        const whereClause = whereClauses.join(" AND ");
+        const result = await h.queryOne(
+          `SELECT COUNT(*) as count FROM "${tableName}" WHERE ${whereClause}`,
+          params
+        );
+        return Number(result?.["count"] ?? 0);
+      },
+      async updateStatus(collection, id, status) {
+        validateCollectionSlug2(collection);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        await h.execute(
+          `UPDATE "${resolveTableName(collection)}" SET "_status" = $1, "updatedAt" = $2 WHERE "id" = $3`,
+          [status, now, id]
+        );
+      },
+      async setScheduledPublishAt(collection, id, publishAt) {
+        validateCollectionSlug2(collection);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        await h.execute(
+          `UPDATE "${resolveTableName(collection)}" SET "scheduledPublishAt" = $1, "updatedAt" = $2 WHERE "id" = $3`,
+          [publishAt, now, id]
+        );
+      },
+      async findScheduledDocuments(collection, before) {
+        validateCollectionSlug2(collection);
+        const rows = await h.query(
+          `SELECT "id", "scheduledPublishAt" FROM "${resolveTableName(collection)}" WHERE "scheduledPublishAt" IS NOT NULL AND "scheduledPublishAt" <= $1`,
+          [before]
+        );
+        return rows.map((row2) => ({
+          id: String(row2["id"]),
+          scheduledPublishAt: String(row2["scheduledPublishAt"])
+        }));
+      }
+    };
+  }
+  const helpers = createHelpers(pool);
+  const methods = buildMethods(helpers);
+  return {
+    /**
+     * Get the pg Pool instance for Better Auth integration.
+     */
+    getPool() {
+      return pool;
+    },
+    /**
+     * Execute a raw SQL query.
+     */
+    query: helpers.query,
+    /**
+     * Execute a raw SQL query and return a single row.
+     */
+    queryOne: helpers.queryOne,
+    /**
+     * Execute a raw SQL statement.
+     */
+    execute: helpers.execute,
+    // Spread all CRUD + version methods
+    ...methods,
+    async initialize(collections) {
+      await ensureDatabaseExists(options.connectionString);
+      for (const collection of collections) {
+        const tbl = getTableName2(collection);
+        tableNameMap.set(collection.slug, tbl);
+      }
+      await pool.query(SEED_TRACKING_TABLE_SQL2);
+      for (const collection of collections) {
+        const tbl = getTableName2(collection);
+        const createSql = createTableSql2(collection);
+        await pool.query(createSql);
+        const dataFields = flattenDataFields(collection.fields);
+        for (const field of dataFields) {
+          const colType = getColumnType2(field);
+          await pool.query(
+            `ALTER TABLE "${tbl}" ADD COLUMN IF NOT EXISTS "${field.name}" ${colType}`
+          );
+        }
+        if (hasVersionDrafts2(collection)) {
+          await pool.query(
+            `ALTER TABLE "${tbl}" ADD COLUMN IF NOT EXISTS "_status" VARCHAR(20) DEFAULT 'draft'`
+          );
+          await pool.query(
+            `ALTER TABLE "${tbl}" ADD COLUMN IF NOT EXISTS "scheduledPublishAt" TIMESTAMPTZ`
+          );
+        }
+        const sdField = getSoftDeleteField(collection);
+        if (sdField) {
+          await pool.query(
+            `ALTER TABLE "${tbl}" ADD COLUMN IF NOT EXISTS "${sdField}" TIMESTAMPTZ`
+          );
+          await pool.query(
+            `CREATE INDEX IF NOT EXISTS "idx_${tbl}_${sdField}" ON "${tbl}"("${sdField}")`
+          );
+        }
+        if (collection.indexes) {
+          for (const idx of collection.indexes) {
+            for (const col of idx.columns) {
+              validateColumnName2(col);
+            }
+            const idxName = idx.name ?? `idx_${tbl}_${idx.columns.join("_")}`;
+            const uniqueStr = idx.unique ? "UNIQUE " : "";
+            const colList = idx.columns.map((c) => `"${c}"`).join(", ");
+            await pool.query(
+              `CREATE ${uniqueStr}INDEX IF NOT EXISTS "${idxName}" ON "${tbl}"(${colList})`
+            );
+          }
+        }
+        const versionTableSql = createVersionTableSql2(collection);
+        if (versionTableSql) {
+          await pool.query(versionTableSql);
+        }
+      }
+      for (const collection of collections) {
+        const tbl = getTableName2(collection);
+        validateCollectionSlug2(collection.slug);
+        const dataFields = flattenDataFields(collection.fields);
+        for (const field of dataFields) {
+          if (field.type === "relationship" && !field.hasMany && !field.relationTo) {
+            const targetSlug = resolveRelationshipSlug(field);
+            if (targetSlug) {
+              const targetTable = resolveTableName(targetSlug);
+              validateCollectionSlug2(targetSlug);
+              validateCollectionSlug2(field.name);
+              const constraintName = `fk_${tbl}_${field.name}`;
+              const isRequired = !!field.required;
+              const onDeleteSql = mapOnDelete(field.onDelete, isRequired);
+              if (isRequired) {
+                await pool.query(
+                  `DELETE FROM "${tbl}" WHERE "${field.name}" IS NOT NULL AND "${field.name}" NOT IN (SELECT "id" FROM "${targetTable}")`
+                );
+              } else {
+                await pool.query(
+                  `UPDATE "${tbl}" SET "${field.name}" = NULL WHERE "${field.name}" IS NOT NULL AND "${field.name}" NOT IN (SELECT "id" FROM "${targetTable}")`
+                );
+              }
+              await pool.query(`
+								DO $$ BEGIN
+									IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}') THEN
+										ALTER TABLE "${tbl}"
+											ADD CONSTRAINT "${constraintName}"
+											FOREIGN KEY ("${field.name}")
+											REFERENCES "${targetTable}"("id")
+											${onDeleteSql};
+									END IF;
+								END $$;
+							`);
+            }
+          }
+        }
+      }
+    },
+    // ============================================
+    // Globals Support
+    // ============================================
+    async initializeGlobals(_globals) {
+      await pool.query(`
+				CREATE TABLE IF NOT EXISTS "_globals" (
+					"slug" VARCHAR(255) PRIMARY KEY,
+					"data" JSONB NOT NULL DEFAULT '{}',
+					"createdAt" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+					"updatedAt" TIMESTAMPTZ NOT NULL DEFAULT NOW()
+				)
+			`);
+    },
+    async findGlobal(slug2) {
+      const result = await pool.query('SELECT * FROM "_globals" WHERE "slug" = $1', [
+        slug2
+      ]);
+      if (result.rows.length === 0)
+        return null;
+      const row2 = result.rows[0];
+      const data = typeof row2["data"] === "string" ? JSON.parse(row2["data"]) : row2["data"];
+      return {
+        ...data,
+        slug: row2["slug"],
+        createdAt: row2["createdAt"],
+        updatedAt: row2["updatedAt"]
+      };
+    },
+    async updateGlobal(slug2, data) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const jsonData = JSON.stringify(data);
+      const result = await pool.query(
+        `INSERT INTO "_globals" ("slug", "data", "createdAt", "updatedAt")
+				 VALUES ($1, $2::jsonb, $3, $4)
+				 ON CONFLICT ("slug") DO UPDATE SET "data" = $2::jsonb, "updatedAt" = $4
+				 RETURNING *`,
+        [slug2, jsonData, now, now]
+      );
+      const row2 = result.rows[0];
+      const returned = typeof row2["data"] === "string" ? JSON.parse(row2["data"]) : row2["data"];
+      return {
+        ...returned,
+        slug: row2["slug"],
+        createdAt: row2["createdAt"],
+        updatedAt: row2["updatedAt"]
+      };
+    },
+    async transaction(callback) {
+      const client = await pool.connect();
+      try {
+        await client.query("BEGIN");
+        const txHelpers = createHelpers(client);
+        const txAdapter = buildMethods(txHelpers);
+        const result = await callback(txAdapter);
+        await client.query("COMMIT");
+        return result;
+      } catch (error) {
+        await client.query("ROLLBACK");
+        throw error;
+      } finally {
+        client.release();
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  postgresAdapter,
+  sqliteAdapter
+});