opacacms 0.1.7 → 0.1.8

package/dist/db/postgres.js

@@ -1,24 +1,323 @@
-import {
-  buildKyselyWhere,
-  flattenPayload,
-  pushSchema,
-  unflattenRow
-} from "../chunk-6ew02s0c.js";
-import {
-  logger
-} from "../chunk-62ev8gnc.js";
-import {
-  toSnakeCase
-} from "../chunk-cvdd4eqh.js";
-import"../chunk-ybbbqj63.js";
-import {
-  BaseDatabaseAdapter
-} from "../chunk-s8mqwnm1.js";
-import {
-  __require
-} from "../chunk-8sqjbsgt.js";
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m", BLUE = "\x1B[34m", GREEN = "\x1B[32m", YELLOW = "\x1B[33m", RED = "\x1B[31m", GRAY = "\x1B[90m", PREFIX, logger;
+var init_logger = __esm(() => {
+  PREFIX = `${BLUE}[OpacaCMS]${RESET}`;
+  logger = {
+    info: (message, ...args) => {
+      console.log(`${PREFIX} ${message}`, ...args);
+    },
+    success: (message, ...args) => {
+      console.log(`${PREFIX} ${GREEN}${message}${RESET}`, ...args);
+    },
+    debug: (message, ...args) => {
+      console.log(`${PREFIX} ${GRAY}${message}${RESET}`, ...args);
+    },
+    warn: (message, ...args) => {
+      console.warn(`${PREFIX} ${YELLOW}Warning: ${message}${RESET}`, ...args);
+    },
+    error: (message, ...args) => {
+      console.error(`${PREFIX} ${RED}Error: ${message}${RESET}`, ...args);
+    },
+    format: (color, msg) => {
+      switch (color) {
+        case "green":
+          return `${GREEN}${msg}${RESET}`;
+        case "red":
+          return `${RED}${msg}${RESET}`;
+        case "yellow":
+          return `${YELLOW}${msg}${RESET}`;
+        case "gray":
+          return `${GRAY}${msg}${RESET}`;
+        default:
+          return msg;
+      }
+    }
+  };
+});
+
+// src/db/kysely/field-mapper.ts
+var exports_field_mapper = {};
+__export(exports_field_mapper, {
+  toSnakeCase: () => toSnakeCase,
+  mapFieldToSQLiteType: () => mapFieldToSQLiteType,
+  mapFieldToPostgresType: () => mapFieldToPostgresType,
+  getRelationalFields: () => getRelationalFields,
+  flattenFields: () => flattenFields
+});
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function mapFieldToPostgresType(field) {
+  switch (field.type) {
+    case "text":
+    case "richtext":
+    case "select":
+    case "radio":
+    case "relationship":
+      return "text";
+    case "number":
+      return "double precision";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "timestamp with time zone";
+    case "json":
+    case "file":
+      return "jsonb";
+    default:
+      return "text";
+  }
+}
+function mapFieldToSQLiteType(field) {
+  switch (field.type) {
+    case "text":
+    case "richtext":
+    case "select":
+    case "radio":
+    case "relationship":
+    case "date":
+    case "json":
+    case "file":
+      return "text";
+    case "number":
+      return "numeric";
+    case "boolean":
+      return "integer";
+    default:
+      return "text";
+  }
+}
+function flattenFields(fields, prefix = "") {
+  const result = [];
+  for (const field of fields) {
+    if (field.type === "join" || field.type === "virtual")
+      continue;
+    const currentName = field.name ? `${prefix}${field.name}` : undefined;
+    if (field.type === "group") {
+      if (field.fields && Array.isArray(field.fields)) {
+        const nextPrefix = currentName ? `${currentName}__` : "";
+        result.push(...flattenFields(field.fields, nextPrefix));
+      }
+      continue;
+    }
+    if (field.type === "blocks") {
+      continue;
+    }
+    if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+      continue;
+    }
+    if (currentName) {
+      result.push({ ...field, name: currentName });
+    }
+    if (field.type === "row" || field.type === "collapsible") {
+      if (field.fields && Array.isArray(field.fields)) {
+        result.push(...flattenFields(field.fields, prefix));
+      }
+    }
+    if (field.type === "tabs" && field.tabs && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        if (tab.fields && Array.isArray(tab.fields)) {
+          result.push(...flattenFields(tab.fields, prefix));
+        }
+      }
+    }
+  }
+  return result;
+}
+function getRelationalFields(fields, prefix = "") {
+  const result = [];
+  for (const field of fields) {
+    const currentName = field.name ? `${prefix}${field.name}` : undefined;
+    if (field.type === "relationship" && "hasMany" in field && field.hasMany || field.type === "blocks") {
+      if (currentName) {
+        result.push({ ...field, name: currentName });
+      }
+      continue;
+    }
+    if (field.type === "group" || field.type === "row" || field.type === "collapsible") {
+      if (field.fields && Array.isArray(field.fields)) {
+        const nextPrefix = field.type === "group" && field.name ? `${currentName}__` : prefix;
+        result.push(...getRelationalFields(field.fields, nextPrefix));
+      }
+      continue;
+    }
+    if (field.type === "tabs" && field.tabs && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        if (tab.fields && Array.isArray(tab.fields)) {
+          result.push(...getRelationalFields(tab.fields, prefix));
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/db/system-schema.ts
+var exports_system_schema = {};
+__export(exports_system_schema, {
+  getSystemCollections: () => getSystemCollections
+});
+var getSystemCollections = () => [
+  {
+    slug: "_opaca_assets",
+    label: "Assets",
+    apiPath: "assets",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "key", type: "text", required: true },
+      { name: "filename", type: "text", required: true },
+      { name: "originalFilename", type: "text", required: true },
+      { name: "mimeType", type: "text", required: true },
+      { name: "filesize", type: "number", required: true },
+      { name: "bucket", type: "text", required: true },
+      { name: "folder", type: "text" },
+      { name: "altText", type: "text" },
+      { name: "caption", type: "text" },
+      { name: "uploadedBy", type: "text" }
+    ],
+    timestamps: true
+  },
+  {
+    slug: "_users",
+    apiPath: "users",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "name", type: "text", required: true },
+      { name: "email", type: "text", required: true, unique: true },
+      { name: "emailVerified", type: "boolean", required: true, defaultValue: false },
+      { name: "image", type: "text" },
+      { name: "role", type: "text" },
+      { name: "banned", type: "boolean" },
+      { name: "banReason", type: "text" },
+      { name: "banExpires", type: "date" }
+    ],
+    timestamps: true
+  },
+  {
+    slug: "_sessions",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "expiresAt", type: "date", required: true },
+      { name: "token", type: "text", required: true, unique: true },
+      { name: "ipAddress", type: "text" },
+      { name: "userAgent", type: "text" },
+      {
+        name: "userId",
+        type: "text",
+        required: true,
+        references: { table: "_users", column: "id", onDelete: "cascade" }
+      },
+      { name: "impersonatedBy", type: "text" }
+    ],
+    timestamps: true,
+    hidden: true
+  },
+  {
+    slug: "_accounts",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "accountId", type: "text", required: true },
+      { name: "providerId", type: "text", required: true },
+      {
+        name: "userId",
+        type: "text",
+        required: true,
+        references: { table: "_users", column: "id", onDelete: "cascade" }
+      },
+      { name: "accessToken", type: "text" },
+      { name: "refreshToken", type: "text" },
+      { name: "idToken", type: "text" },
+      { name: "accessTokenExpiresAt", type: "date" },
+      { name: "refreshTokenExpiresAt", type: "date" },
+      { name: "scope", type: "text" },
+      { name: "password", type: "text" }
+    ],
+    timestamps: true,
+    hidden: true
+  },
+  {
+    slug: "_verifications",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "identifier", type: "text", required: true },
+      { name: "value", type: "text", required: true },
+      { name: "expiresAt", type: "date", required: true }
+    ],
+    timestamps: true,
+    hidden: true
+  },
+  {
+    slug: "_api_keys",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "configId", type: "text", required: true },
+      { name: "name", type: "text" },
+      { name: "start", type: "text" },
+      { name: "prefix", type: "text" },
+      { name: "key", type: "text", required: true },
+      { name: "referenceId", type: "text", required: true },
+      { name: "refillInterval", type: "number" },
+      { name: "refillAmount", type: "number" },
+      { name: "lastRefillAt", type: "date" },
+      { name: "enabled", type: "boolean", required: true },
+      { name: "rateLimitEnabled", type: "boolean", required: true },
+      { name: "rateLimitTimeWindow", type: "number" },
+      { name: "rateLimitMax", type: "number" },
+      { name: "requestCount", type: "number", required: true },
+      { name: "remaining", type: "number" },
+      { name: "lastRequest", type: "date" },
+      { name: "expiresAt", type: "date" },
+      { name: "permissions", type: "text" },
+      { name: "metadata", type: "text" }
+    ],
+    timestamps: { createdAt: "createdAt", updatedAt: "updatedAt" },
+    hidden: true
+  }
+];
 
 // src/db/postgres.ts
+init_logger();
 import fs from "node:fs/promises";
 import path from "node:path";
 import {
@@ -29,6 +328,476 @@ import {
   PostgresDialect
 } from "kysely";
 import postgres from "postgres";
+
+// src/db/adapter.ts
+class BaseDatabaseAdapter {
+  get raw() {
+    return;
+  }
+  get db() {
+    return;
+  }
+  push;
+  pushDestructive;
+  migrationDir;
+}
+
+// src/db/kysely/data-mapper.ts
+function toCamelCase(str) {
+  if (str.startsWith("_"))
+    return str;
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function flattenPayload(payload, prefix = "", excludeKeys = []) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+    return payload;
+  const result = {};
+  for (const key in payload) {
+    if (Object.hasOwn(payload, key)) {
+      const value = payload[key];
+      if (value === undefined)
+        continue;
+      if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !excludeKeys.includes(key)) {
+        if (key.startsWith("_") && prefix === "") {
+          result[key] = value;
+        } else {
+          const flatNested = flattenPayload(value, `${prefix}${key}__`);
+          Object.assign(result, flatNested);
+        }
+      } else {
+        if (value === undefined)
+          continue;
+        const colName = `${prefix}${toSnakeCase(key)}`;
+        if (typeof value === "object" && value !== null) {
+          result[colName] = JSON.stringify(value);
+        } else {
+          result[colName] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+function unflattenRow(row) {
+  if (typeof row !== "object" || row === null || Array.isArray(row))
+    return row;
+  const result = {};
+  for (const key in row) {
+    if (Object.hasOwn(row, key)) {
+      let value = row[key];
+      if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
+          try {
+            value = JSON.parse(value);
+          } catch (e) {}
+        }
+      }
+      if (key === "created_at" || key === "updated_at" || key === "createdAt" || key === "updatedAt") {
+        if (typeof value === "string" && !value.includes("T") && value.includes(" ")) {
+          value = `${value.replace(" ", "T")}Z`;
+        }
+        result[toCamelCase(key)] = value;
+        continue;
+      }
+      if (key.startsWith("_")) {
+        result[key] = value;
+        continue;
+      }
+      const parts = key.split("__");
+      if (parts.length === 1) {
+        result[toCamelCase(key)] = value;
+        continue;
+      }
+      let current = result;
+      let collision = false;
+      const path = [];
+      for (let i = 0;i < parts.length - 1; i++) {
+        const part = toCamelCase(parts[i]);
+        if (current[part] !== undefined && (typeof current[part] !== "object" || current[part] === null)) {
+          collision = true;
+          break;
+        }
+        path.push({ obj: current, key: part });
+        if (!current[part]) {
+          current[part] = {};
+        }
+        current = current[part];
+      }
+      if (!collision) {
+        const lastPart = toCamelCase(parts[parts.length - 1]);
+        if (current[lastPart] !== undefined && typeof current[lastPart] === "object") {
+          collision = true;
+        } else {
+          current[lastPart] = value;
+        }
+      }
+      if (collision) {
+        result[toCamelCase(key)] = value;
+      }
+    }
+  }
+  return result;
+}
+// src/db/kysely/query-builder.ts
+function buildKyselyWhere(eb, query) {
+  if (!query || Object.keys(query).length === 0)
+    return;
+  const conditions = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined)
+      continue;
+    if (key === "or" && Array.isArray(value)) {
+      const orConditions = value.map((v) => buildKyselyWhere(eb, v)).filter((c) => c !== undefined);
+      if (orConditions.length > 0) {
+        conditions.push(eb.or(orConditions));
+      }
+      continue;
+    }
+    if (key === "and" && Array.isArray(value)) {
+      const andConditions = value.map((v) => buildKyselyWhere(eb, v)).filter((c) => c !== undefined);
+      if (andConditions.length > 0) {
+        conditions.push(eb.and(andConditions));
+      }
+      continue;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
+      for (const [op, val] of Object.entries(value)) {
+        if (val === undefined)
+          continue;
+        switch (op) {
+          case "gt":
+            conditions.push(eb(key, ">", val));
+            break;
+          case "gte":
+            conditions.push(eb(key, ">=", val));
+            break;
+          case "lt":
+            conditions.push(eb(key, "<", val));
+            break;
+          case "lte":
+            conditions.push(eb(key, "<=", val));
+            break;
+          case "like":
+            conditions.push(eb(key, "like", String(val)));
+            break;
+          case "ne":
+            if (val === null)
+              conditions.push(eb(key, "is not", null));
+            else
+              conditions.push(eb(key, "!=", val));
+            break;
+          case "in":
+            if (Array.isArray(val))
+              conditions.push(eb(key, "in", val));
+            break;
+          case "is":
+            if (val === null)
+              conditions.push(eb(key, "is", null));
+            break;
+          default:
+            if (val === null)
+              conditions.push(eb(key, "is", null));
+            else
+              conditions.push(eb(key, "=", val));
+            break;
+        }
+      }
+    } else {
+      if (value === null) {
+        conditions.push(eb(key, "is", null));
+      } else {
+        conditions.push(eb(key, "=", value));
+      }
+    }
+  }
+  if (conditions.length === 0)
+    return;
+  if (conditions.length === 1)
+    return conditions[0];
+  return eb.and(conditions);
+}
+
+// src/db/kysely/schema-builder.ts
+init_logger();
+import { sql } from "kysely";
+
+// src/db/kysely/sql-utils.ts
+function assertSafeIdentifier(identifier) {
+  if (typeof identifier !== "string" || !identifier) {
+    throw new Error(`Invalid identifier: must be a non-empty string. Got: ${identifier}`);
+  }
+  const isValid = /^[a-zA-Z0-9_-]+$/.test(identifier);
+  if (!isValid) {
+    throw new Error(`API Error: Unsafe SQL identifier detected: "${identifier}". Identifiers can only contain alphanumeric characters, underscores, and hyphens.`);
+  }
+}
+
+// src/db/kysely/schema-builder.ts
+async function pushSchema(db, dialect, collections, globals = [], options = {}) {
+  const rawSchemas = [...getSystemCollections(), ...collections, ...globals];
+  const allSchemas = [];
+  const seenSlugs = new Set;
+  for (const schema of rawSchemas) {
+    if (!seenSlugs.has(schema.slug)) {
+      seenSlugs.add(schema.slug);
+      allSchemas.push(schema);
+    }
+  }
+  const { pushDestructive } = options;
+  logger.debug(`Starting schema push via Kysely (${dialect})...`);
+  const mapType = dialect === "postgres" ? mapFieldToPostgresType : mapFieldToSQLiteType;
+  let existingTables = [];
+  try {
+    if (dialect === "postgres") {
+      const res = await sql`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`.execute(db);
+      existingTables = res.rows.map((r) => r.table_name);
+    } else {
+      const res = await sql`SELECT name FROM sqlite_master WHERE type='table'`.execute(db);
+      existingTables = res.rows.map((r) => r.name);
+    }
+  } catch (_) {
+    logger.warn("Failed to fetch existing tables:");
+  }
+  logger.info(`Existing tables: ${existingTables.join(", ")}`);
+  const existingTableSet = new Set(existingTables);
+  const expectedTableNames = new Set;
+  for (const collection of allSchemas) {
+    const slug = collection.slug;
+    const tableName = toSnakeCase(slug);
+    assertSafeIdentifier(tableName);
+    expectedTableNames.add(tableName);
+    const flattenedFields = flattenFields(collection.fields);
+    const hasTimestamps = collection.timestamps !== false;
+    const versions = collection.versions;
+    if (!existingTableSet.has(tableName)) {
+      logger.info(`  -> Creating table: ${logger.format("green", `"${tableName}"`)}`);
+      let builder = db.schema.createTable(tableName).ifNotExists();
+      builder = builder.addColumn("id", "text", (col) => col.primaryKey());
+      for (const field of flattenedFields) {
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany)
+          continue;
+        const colName = toSnakeCase(field.name);
+        if (colName === "id")
+          continue;
+        assertSafeIdentifier(colName);
+        const colType = mapType(field);
+        builder = builder.addColumn(colName, colType, (col) => {
+          let c = col;
+          if (field.unique)
+            c = c.unique();
+          if (field.required)
+            c = c.notNull();
+          if (field.defaultValue !== undefined)
+            c = c.defaultTo(field.defaultValue);
+          return c;
+        });
+      }
+      if (versions?.drafts) {
+        builder = builder.addColumn("_status", "text", (col) => col.defaultTo("draft"));
+      }
+      if (hasTimestamps) {
+        const ts = collection.timestamps ?? {};
+        const config = typeof ts === "object" ? ts : {};
+        const createdField = toSnakeCase(config.createdAt ?? "createdAt");
+        const updatedField = toSnakeCase(config.updatedAt ?? "updatedAt");
+        const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
+        builder = builder.addColumn(createdField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+        builder = builder.addColumn(updatedField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+      }
+      await builder.execute();
+      if (versions) {
+        const versionsTable = `${slug}_versions`.toLowerCase();
+        assertSafeIdentifier(versionsTable);
+        expectedTableNames.add(versionsTable);
+        if (!existingTableSet.has(versionsTable)) {
+          logger.info(`  -> Creating versions table: ${logger.format("green", `"${versionsTable}"`)}`);
+          await db.schema.createTable(versionsTable).addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", "text", (col) => col.notNull()).addColumn("_version_data", dialect === "postgres" ? "jsonb" : "text", (col) => col.notNull()).addColumn("_status", "text").addColumn("created_at", dialect === "postgres" ? "timestamp with time zone" : "text", (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+      }
+    } else {
+      let existingColumns = [];
+      try {
+        if (dialect === "postgres") {
+          const res = await sql`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ${slug}`.execute(db);
+          existingColumns = res.rows.map((r) => r.column_name);
+        } else {
+          const res = await sql`PRAGMA table_info(${sql.id(slug)})`.execute(db);
+          existingColumns = res.rows.map((r) => r.name);
+        }
+      } catch (e) {
+        logger.warn(`Failed to fetch columns for ${slug}:`, e);
+      }
+      const existingColSet = new Set(existingColumns);
+      for (const field of flattenedFields) {
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany)
+          continue;
+        const colName = toSnakeCase(field.name);
+        if (colName === "id")
+          continue;
+        assertSafeIdentifier(colName);
+        if (!existingColSet.has(colName)) {
+          logger.info(`  -> Adding missing column: ${logger.format("green", `${slug}.${colName}`)}`);
+          const colType = mapType(field);
+          await db.schema.alterTable(slug).addColumn(colName, colType).execute();
+        }
+      }
+      if (versions?.drafts && !existingColSet.has("_status")) {
+        logger.info(`  -> Adding missing status column to: ${slug}`);
+        await db.schema.alterTable(slug).addColumn("_status", "text", (col) => col.defaultTo("draft")).execute();
+      }
+      if (hasTimestamps) {
+        const ts = collection.timestamps ?? {};
+        const config = typeof ts === "object" ? ts : {};
+        const createdField = toSnakeCase(config.createdAt ?? "createdAt");
+        const updatedField = toSnakeCase(config.updatedAt ?? "updatedAt");
+        const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
+        if (!existingColSet.has(createdField)) {
+          logger.info(`  -> Adding missing timestamp column: ${slug}.${createdField}`);
+          await db.schema.alterTable(slug).addColumn(createdField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+        if (!existingColSet.has(updatedField)) {
+          logger.info(`  -> Adding missing timestamp column: ${slug}.${updatedField}`);
+          await db.schema.alterTable(slug).addColumn(updatedField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+      }
+      if (versions) {
+        const versionsTable = `${slug}_versions`.toLowerCase();
+        expectedTableNames.add(versionsTable);
+        if (!existingTableSet.has(versionsTable)) {
+          logger.info(`  -> Creating missing versions table for: ${slug}`);
+          await db.schema.createTable(versionsTable).addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", "text", (col) => col.notNull()).addColumn("_version_data", dialect === "postgres" ? "jsonb" : "text", (col) => col.notNull()).addColumn("_status", "text").addColumn("created_at", dialect === "postgres" ? "timestamp with time zone" : "text", (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+      }
+      if (pushDestructive) {
+        const expectedCols = new Set(flattenedFields.filter((f) => !(f.type === "relationship" && f.hasMany)).map((f) => toSnakeCase(f.name)));
+        if (hasTimestamps) {
+          const ts = collection.timestamps ?? {};
+          const config = typeof ts === "object" ? ts : {};
+          expectedCols.add(toSnakeCase(config.createdAt ?? "createdAt"));
+          expectedCols.add(toSnakeCase(config.updatedAt ?? "updatedAt"));
+        }
+        if (versions?.drafts)
+          expectedCols.add("_status");
+        expectedCols.add("id");
+        for (const existingCol of existingColumns) {
+          if (!expectedCols.has(existingCol)) {
+            logger.info(`  -> Dropping stale column: ${logger.format("red", `${slug}.${existingCol}`)}`);
+            try {
+              await db.schema.alterTable(slug).dropColumn(existingCol).execute();
+            } catch (_) {
+              logger.warn(`Failed to drop column ${existingCol}.`);
+            }
+          }
+        }
+      }
+    }
+    const relationalFields = getRelationalFields(collection.fields);
+    for (const field of relationalFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+        const sourceIdType = "text";
+        const colName = toSnakeCase(field.name);
+        const joinTableName = `${slug}_${colName}_relations`.toLowerCase();
+        assertSafeIdentifier(joinTableName);
+        expectedTableNames.add(joinTableName);
+        if (!existingTableSet.has(joinTableName)) {
+          logger.info(`  -> Creating relation table: ${logger.format("green", `"${joinTableName}"`)}`);
+          await db.schema.createTable(joinTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("source_id", sourceIdType, (col) => col.notNull()).addColumn("target_id", "text", (col) => col.notNull()).addColumn("order", "integer", (col) => col.defaultTo(0)).execute();
+        }
+      }
+    }
+    for (const field of relationalFields) {
+      if (field.type === "blocks" && field.blocks && Array.isArray(field.blocks)) {
+        const parentIdType = "text";
+        for (const block of field.blocks) {
+          const blockName = toSnakeCase(field.name);
+          const blockSlug = toSnakeCase(block.slug);
+          assertSafeIdentifier(blockName);
+          assertSafeIdentifier(blockSlug);
+          const blockTableName = `${slug}_${blockName}_${blockSlug}`.toLowerCase();
+          assertSafeIdentifier(blockTableName);
+          expectedTableNames.add(blockTableName);
+          if (!existingTableSet.has(blockTableName)) {
+            logger.info(`  -> Creating block table: ${logger.format("green", `"${blockTableName}"`)}`);
+            let bBuilder = db.schema.createTable(blockTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", parentIdType, (col) => col.notNull()).addColumn("_order", "integer", (col) => col.defaultTo(0)).addColumn("block_type", "text", (col) => col.notNull().defaultTo(block.slug));
+            const blockFlattened = flattenFields(block.fields);
+            for (const bField of blockFlattened) {
+              const bColName = toSnakeCase(bField.name);
+              if (bColName === "id")
+                continue;
+              assertSafeIdentifier(bColName);
+              const bColType = mapType(bField);
+              bBuilder = bBuilder.addColumn(bColName, bColType, (col) => {
+                let c = col;
+                if (bField.unique)
+                  c = c.unique();
+                if (bField.required)
+                  c = c.notNull();
+                if (bField.defaultValue !== undefined)
+                  c = c.defaultTo(bField.defaultValue);
+                return c;
+              });
+            }
+            const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
+            bBuilder = bBuilder.addColumn("created_at", tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+            bBuilder = bBuilder.addColumn("updated_at", tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+            await bBuilder.execute();
+          } else {
+            let existingBCols = [];
+            try {
+              if (dialect === "postgres") {
+                const res = await sql`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ${blockTableName}`.execute(db);
+                existingBCols = res.rows.map((r) => r.column_name);
+              } else {
+                const res = await sql`PRAGMA table_info(${sql.id(blockTableName)})`.execute(db);
+                existingBCols = res.rows.map((r) => r.name);
+              }
+            } catch (_) {}
+            const existingBColSet = new Set(existingBCols);
+            const blockFlattened = flattenFields(block.fields);
+            for (const bField of blockFlattened) {
+              const bColName = toSnakeCase(bField.name);
+              if (bColName === "id")
+                continue;
+              if (!existingBColSet.has(bColName)) {
+                const bColType = mapType(bField);
+                await db.schema.alterTable(blockTableName).addColumn(bColName, bColType).execute();
+              }
+            }
+            if (!existingBColSet.has("_parent_id")) {
+              await db.schema.alterTable(blockTableName).addColumn("_parent_id", "text", (col) => col.notNull().defaultTo("")).execute();
+            }
+            if (!existingBColSet.has("_order")) {
+              await db.schema.alterTable(blockTableName).addColumn("_order", "integer", (col) => col.defaultTo(0)).execute();
+            }
+            if (!existingBColSet.has("block_type")) {
+              await db.schema.alterTable(blockTableName).addColumn("block_type", "text", (col) => col.notNull().defaultTo(block.slug)).execute();
+            }
+          }
+        }
+      }
+    }
+  }
+  if (pushDestructive) {
+    for (const tableName of existingTables) {
+      if (!expectedTableNames.has(tableName) && !tableName.startsWith("better_auth") && !tableName.startsWith("__kysely")) {
+        logger.info(`  -> Dropping stale table: ${logger.format("red", `"${tableName}"`)}`);
+        try {
+          await db.schema.dropTable(tableName).ifExists().cascade().execute();
+        } catch (_) {
+          try {
+            await db.schema.dropTable(tableName).ifExists().execute();
+          } catch (_2) {
+            logger.warn(`Failed to drop table ${tableName}`);
+          }
+        }
+      }
+    }
+  }
+  logger.success(`Schema push to Kysely (${dialect}) completed.`);
+}
+
+// src/db/postgres.ts
 class PostgresAdapter extends BaseDatabaseAdapter {
   name = "postgres";
   _rawDb = null;
@@ -185,8 +954,8 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     const unflattened = unflattenRow(row);
     const colDef = this._collections.find((c) => c.slug === collection);
     if (colDef) {
-      const { getRelationalFields, toSnakeCase: toSnakeCase2 } = await import("../chunk-xg35h5a3.js");
-      const relationalFields = getRelationalFields(colDef.fields);
+      const { getRelationalFields: getRelationalFields2, toSnakeCase: toSnakeCase2 } = await Promise.resolve().then(() => exports_field_mapper);
+      const relationalFields = getRelationalFields2(colDef.fields);
       for (const field of relationalFields) {
         if (!field.name)
           continue;
@@ -501,8 +1270,8 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     }
   }
   async migrate(collections, globals = []) {
-    const { getSystemCollections } = await import("../chunk-v521d72w.js");
-    this._collections = [...getSystemCollections(), ...collections];
+    const { getSystemCollections: getSystemCollections2 } = await Promise.resolve().then(() => exports_system_schema);
+    this._collections = [...getSystemCollections2(), ...collections];
     this._globals = globals;
     if (this.push && this._db) {
       await pushSchema(this._db, "postgres", collections, globals, {