@nexpress/core 0.1.0

package/dist/chunk-TFJ4MKPH.js

@@ -0,0 +1,694 @@
+import {
+  schema_exports
+} from "./chunk-PPAS4SZR.js";
+import {
+  readEnvPositiveInt
+} from "./chunk-OROPGO65.js";
+
+// src/db/connection.ts
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+var DEFAULT_CONNECTION_TIMEOUT_MS = readEnvPositiveInt("NP_DB_CONNECTION_TIMEOUT_MS", 5e3);
+var DEFAULT_STATEMENT_TIMEOUT_MS = readEnvPositiveInt("NP_DB_STATEMENT_TIMEOUT_MS", 1e4);
+function createDbConnection(config) {
+  const pool = config.pool ?? new Pool({
+    connectionString: config.connectionString,
+    connectionTimeoutMillis: DEFAULT_CONNECTION_TIMEOUT_MS,
+    statement_timeout: DEFAULT_STATEMENT_TIMEOUT_MS,
+    ...config.poolOptions
+  });
+  return drizzle(pool, { schema: schema_exports });
+}
+
+// src/db/generator.ts
+function generateDrizzleSchema(collections, options) {
+  const schemaImport = options?.schemaImport ?? "@nexpress/core";
+  const collectionTables = /* @__PURE__ */ new Map();
+  for (const collection of collections) {
+    collectionTables.set(collection.slug, getCollectionTableIdentifier(collection.slug));
+  }
+  const tables = [];
+  for (const collection of collections) {
+    const tableIdentifier = getCollectionTableIdentifier(collection.slug);
+    const tableName = `np_c_${collection.slug}`;
+    const columns = getBaseColumns(collection);
+    const indexes = [`index("${tableName}_status_idx").on(table.status)`];
+    const relations = [
+      {
+        key: "createdByUser",
+        kind: "one",
+        targetIdentifier: "npUsers",
+        fields: ["createdBy"],
+        references: ["id"]
+      },
+      {
+        key: "updatedByUser",
+        kind: "one",
+        targetIdentifier: "npUsers",
+        fields: ["updatedBy"],
+        references: ["id"]
+      }
+    ];
+    const memberAuthored = Boolean(collection.community?.memberWrite?.create);
+    if (memberAuthored) {
+      columns.push(
+        'memberAuthorId: uuid("member_author_id").references(() => npMembers.id, { onDelete: "set null" })'
+      );
+      indexes.push(
+        `index("${tableName}_member_author_idx").on(table.memberAuthorId)`
+      );
+      relations.push({
+        key: "memberAuthor",
+        kind: "one",
+        targetIdentifier: "npMembers",
+        fields: ["memberAuthorId"],
+        references: ["id"]
+      });
+    }
+    const scalarResult = collectScalarColumns(collection.fields, [], collectionTables);
+    columns.push(...scalarResult.columns);
+    relations.push(...scalarResult.relations);
+    if (hasSlugField(collection)) {
+      columns.push('slug: text("slug").notNull()');
+      if (collection.i18n) {
+        indexes.push(
+          `uniqueIndex("${tableName}_site_locale_slug_idx").on(table.siteId, table.locale, table.slug)`
+        );
+      } else {
+        indexes.push(
+          `uniqueIndex("${tableName}_site_slug_idx").on(table.siteId, table.slug)`
+        );
+      }
+    }
+    if (collection.i18n) {
+      columns.push('locale: text("locale").notNull()');
+      columns.push('translationGroupId: uuid("translation_group_id").notNull()');
+      indexes.push(
+        `index("${tableName}_translation_group_idx").on(table.translationGroupId)`
+      );
+      indexes.push(
+        `index("${tableName}_locale_idx").on(table.locale)`
+      );
+    }
+    columns.push(
+      'siteId: text("site_id").default("default").notNull()'
+    );
+    indexes.push(`index("${tableName}_site_idx").on(table.siteId)`);
+    if (hasDraftVersions(collection)) {
+      columns.push(
+        '_status: text("_status", { enum: ["draft", "published"] }).default("draft").notNull()'
+      );
+    }
+    columns.push('searchVector: tsvector("search_vector")');
+    tables.push({
+      identifier: tableIdentifier,
+      tableName,
+      columns,
+      indexes,
+      relations
+    });
+    createNestedTables(
+      {
+        collectionSlug: collection.slug,
+        tableIdentifier,
+        tableName,
+        relationKeyPrefix: toCamelCase(collection.slug),
+        fieldPath: [],
+        parentReferenceName: `${toCamelCase(collection.slug)}Id`
+      },
+      collection.fields,
+      tables,
+      collectionTables
+    );
+  }
+  const body = tables.map(renderTable).join("\n\n");
+  const usesMembers = collections.some((c) => c.community?.memberWrite?.create);
+  const schemaImports = ["npMedia", "npUsers", ...usesMembers ? ["npMembers"] : []];
+  return [
+    'import { relations } from "drizzle-orm";',
+    'import { boolean, customType, doublePrecision, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";',
+    `import { ${schemaImports.join(", ")} } from "${schemaImport}";`,
+    "",
+    "const tsvector = customType<{ data: string }>({",
+    "  dataType() {",
+    '    return "tsvector";',
+    "  },",
+    "});",
+    "",
+    body
+  ].join("\n");
+}
+function createNestedTables(context, fields, tables, collectionTables) {
+  for (const field of fields) {
+    if (field.type === "group") {
+      createNestedTables(context, field.fields, tables, collectionTables);
+      continue;
+    }
+    if (field.type === "row" || field.type === "collapsible") {
+      createNestedTables(context, field.fields, tables, collectionTables);
+      continue;
+    }
+    if (field.type === "array") {
+      tables.push(createArrayTable(context, field, tables, collectionTables));
+      continue;
+    }
+    if (field.type === "relationship" && field.hasMany && typeof field.relationTo === "string") {
+      tables.push(
+        createHasManyJoinTable(context, { ...field, relationTo: field.relationTo, hasMany: true }, collectionTables)
+      );
+    }
+  }
+}
+function createArrayTable(context, field, tables, collectionTables) {
+  const path = [...context.fieldPath, field.name];
+  const tableName = `np_c_${context.collectionSlug}__${path.join("__")}`;
+  const identifier = getNestedTableIdentifier(context.collectionSlug, path);
+  const columns = [
+    'id: uuid("id").defaultRandom().primaryKey()',
+    `parentId: uuid("parent_id").notNull().references(() => ${context.tableIdentifier}.id, { onDelete: "cascade" })`,
+    'order: integer("order").default(0).notNull()'
+  ];
+  const relations = [
+    {
+      key: "parent",
+      kind: "one",
+      targetIdentifier: context.tableIdentifier,
+      fields: ["parentId"],
+      references: ["id"]
+    }
+  ];
+  const scalarResult = collectScalarColumns(field.fields, [], collectionTables);
+  columns.push(...scalarResult.columns);
+  relations.push(...scalarResult.relations);
+  const nestedContext = {
+    collectionSlug: context.collectionSlug,
+    tableIdentifier: identifier,
+    tableName,
+    relationKeyPrefix: `${context.relationKeyPrefix}${toPascalCase(field.name)}`,
+    fieldPath: path,
+    parentReferenceName: "parentId",
+    parentTargetIdentifier: context.tableIdentifier
+  };
+  createNestedTables(nestedContext, field.fields, tables, collectionTables);
+  return {
+    identifier,
+    tableName,
+    columns,
+    indexes: [`index("${tableName}_parent_idx").on(table.parentId)`],
+    relations
+  };
+}
+function createHasManyJoinTable(context, field, collectionTables) {
+  const path = [...context.fieldPath, field.name];
+  const tableName = `np_c_${context.collectionSlug}__${path.join("__")}`;
+  const identifier = getNestedTableIdentifier(context.collectionSlug, path);
+  const targetIdentifier = resolveRelationTarget(field.relationTo, collectionTables);
+  const parentReferenceName = context.fieldPath.length === 0 ? `${toCamelCase(context.collectionSlug)}Id` : "parentId";
+  return {
+    identifier,
+    tableName,
+    columns: [
+      'id: uuid("id").defaultRandom().primaryKey()',
+      `${parentReferenceName}: uuid("${toSnakeCase(parentReferenceName)}").notNull().references(() => ${context.tableIdentifier}.id, { onDelete: "cascade" })`,
+      `targetId: uuid("target_id").notNull().references(() => ${targetIdentifier}.id, { onDelete: "cascade" })`,
+      'order: integer("order").default(0).notNull()'
+    ],
+    indexes: [
+      `index("${tableName}_${toSnakeCase(parentReferenceName)}_idx").on(table.${parentReferenceName})`,
+      `uniqueIndex("${tableName}_parent_target_uidx").on(table.${parentReferenceName}, table.targetId)`
+    ],
+    relations: [
+      {
+        key: "parent",
+        kind: "one",
+        targetIdentifier: context.tableIdentifier,
+        fields: [parentReferenceName],
+        references: ["id"]
+      },
+      {
+        key: "target",
+        kind: "one",
+        targetIdentifier,
+        fields: ["targetId"],
+        references: ["id"]
+      }
+    ]
+  };
+}
+function collectScalarColumns(fields, prefix, collectionTables) {
+  const columns = [];
+  const relations = [];
+  for (const field of fields) {
+    if (field.type === "group") {
+      const nested = collectScalarColumns(field.fields, [...prefix, field.name], collectionTables);
+      columns.push(...nested.columns);
+      relations.push(...nested.relations);
+      continue;
+    }
+    if (field.type === "row" || field.type === "collapsible") {
+      const nested = collectScalarColumns(field.fields, prefix, collectionTables);
+      columns.push(...nested.columns);
+      relations.push(...nested.relations);
+      continue;
+    }
+    if (field.type === "array") {
+      continue;
+    }
+    if (field.type === "relationship" && field.hasMany) {
+      continue;
+    }
+    const propertyName = getFlattenedFieldName(prefix, field.name);
+    const columnName = toSnakeCase(propertyName);
+    const column = buildScalarColumn(field, propertyName, columnName, collectionTables);
+    if (!column) {
+      continue;
+    }
+    columns.push(...column.columns);
+    relations.push(...column.relations);
+  }
+  return { columns, relations };
+}
+function buildScalarColumn(field, propertyName, columnName, collectionTables) {
+  const notNull = field.required ? ".notNull()" : "";
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "email":
+    case "select":
+    case "radio":
+      return { columns: [`${propertyName}: text("${columnName}")${notNull}`], relations: [] };
+    case "number": {
+      const builder = field.integerOnly ? "integer" : "doublePrecision";
+      return { columns: [`${propertyName}: ${builder}("${columnName}")${notNull}`], relations: [] };
+    }
+    case "richText":
+    case "blocks":
+    case "json":
+      return { columns: [`${propertyName}: jsonb("${columnName}")${notNull}`], relations: [] };
+    case "checkbox":
+      return { columns: [`${propertyName}: boolean("${columnName}")${notNull}`], relations: [] };
+    case "date":
+      return {
+        columns: [`${propertyName}: timestamp("${columnName}", { withTimezone: true })${notNull}`],
+        relations: []
+      };
+    case "upload": {
+      return {
+        columns: [`${propertyName}: uuid("${columnName}").references(() => npMedia.id)${notNull}`],
+        relations: [
+          {
+            key: propertyName,
+            kind: "one",
+            targetIdentifier: "npMedia",
+            fields: [propertyName],
+            references: ["id"]
+          }
+        ]
+      };
+    }
+    case "relationship": {
+      if (typeof field.relationTo !== "string") {
+        return null;
+      }
+      const targetIdentifier = resolveRelationTarget(field.relationTo, collectionTables);
+      return {
+        columns: [`${propertyName}: uuid("${columnName}").references(() => ${targetIdentifier}.id)${notNull}`],
+        relations: [
+          {
+            key: propertyName,
+            kind: "one",
+            targetIdentifier,
+            fields: [propertyName],
+            references: ["id"]
+          }
+        ]
+      };
+    }
+    default:
+      return null;
+  }
+}
+function getBaseColumns(collection) {
+  const columns = ['id: uuid("id").defaultRandom().primaryKey()'];
+  columns.push(
+    'status: text("status", { enum: ["draft", "scheduled", "published", "archived", "pending"] }).default("draft").notNull()'
+  );
+  columns.push('createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()');
+  columns.push('updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()');
+  columns.push('createdBy: uuid("created_by").references(() => npUsers.id)');
+  columns.push('updatedBy: uuid("updated_by").references(() => npUsers.id)');
+  const visibility = 'visibility: text("visibility", { enum: ["public", "private"] }).default("public").notNull()';
+  if (collection.timestamps === false) {
+    return [columns[0], columns[1], columns[4], columns[5], visibility];
+  }
+  columns.push(visibility);
+  return columns;
+}
+function renderTable(table) {
+  const tableSource = [
+    `export const ${table.identifier} = pgTable(`,
+    `  "${table.tableName}",`,
+    "  {",
+    ...table.columns.map((column) => `    ${column},`),
+    "  },",
+    `  (table) => [${table.indexes.join(", ")}],`,
+    ");"
+  ].join("\n");
+  const relationsSource = [
+    `export const ${table.identifier}Relations = relations(${table.identifier}, ({ many, one }) => ({`,
+    ...table.relations.map((relation) => renderRelation(relation, table.identifier)),
+    "}));"
+  ].join("\n");
+  return `${tableSource}
+
+${relationsSource}`;
+}
+function renderRelation(relation, ownerIdentifier) {
+  if (relation.kind === "many") {
+    return `  ${relation.key}: many(${relation.targetIdentifier}),`;
+  }
+  const fields = (relation.fields ?? []).map((field) => `${ownerIdentifier}.${field}`).join(", ");
+  const references = (relation.references ?? []).map((reference) => `${relation.targetIdentifier}.${reference}`).join(", ");
+  return `  ${relation.key}: one(${relation.targetIdentifier}, { fields: [${fields}], references: [${references}] }),`;
+}
+function hasSlugField(collection) {
+  return collection.slugField !== void 0 && collection.slugField !== false;
+}
+function hasDraftVersions(collection) {
+  return Boolean(collection.versions?.drafts);
+}
+function resolveRelationTarget(relationTo, collectionTables) {
+  if (relationTo === "media") {
+    return "npMedia";
+  }
+  if (relationTo === "users") {
+    return "npUsers";
+  }
+  return collectionTables.get(relationTo) ?? getCollectionTableIdentifier(relationTo);
+}
+function getCollectionTableIdentifier(slug) {
+  return `${toCamelCase(slug)}Table`;
+}
+function getNestedTableIdentifier(collectionSlug, path) {
+  return `${toCamelCase(collectionSlug)}${path.map(toPascalCase).join("")}Table`;
+}
+function getFlattenedFieldName(prefix, name) {
+  if (prefix.length === 0) {
+    return toCamelCase(name);
+  }
+  return `${prefix.map(toPascalCase).join("")}${toPascalCase(name)}`.replace(/^./u, (char) => char.toLowerCase());
+}
+function toCamelCase(value) {
+  const parts = splitName(value);
+  const [first = "", ...rest] = parts;
+  return `${first}${rest.map(capitalize).join("")}`;
+}
+function toPascalCase(value) {
+  return splitName(value).map(capitalize).join("");
+}
+function toSnakeCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").toLowerCase();
+}
+function splitName(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).map((part) => part.toLowerCase()).filter(Boolean);
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+// src/db/type-generator.ts
+function generateTypeScript(collections) {
+  const interfaces = collections.map((collection) => renderCollectionInterface(collection));
+  return interfaces.join("\n\n");
+}
+function collectHasManyFields(collection) {
+  const collCamel = toCamelCase2(collection.slug);
+  const parentColumn = `${collCamel}Id`;
+  const out = [];
+  for (const field of collection.fields) {
+    if (field.type === "relationship" && field.hasMany === true) {
+      const joinTable = `${collCamel}${toPascalCase2(field.name)}Table`;
+      out.push({ fieldName: field.name, joinTable, parentColumn });
+    }
+  }
+  return out;
+}
+function generateDocumentsModule(collections) {
+  const hasManyByCollection = new Map(
+    collections.map((c) => [c.slug, collectHasManyFields(c)])
+  );
+  const anyHasMany = Array.from(hasManyByCollection.values()).some(
+    (list) => list.length > 0
+  );
+  const coreImports = [
+    `import {`,
+    `  findDocuments,`,
+    ...anyHasMany ? [`  getDb,`] : [],
+    `  getDocumentById,`,
+    `  type NpAuthUser,`,
+    `  type NpFindOptions,`,
+    `  type NpFindResult,`,
+    `} from "@nexpress/core";`
+  ].join("\n");
+  const drizzleImports = anyHasMany ? [
+    `import { inArray } from "drizzle-orm";`,
+    `import type { NodePgDatabase } from "drizzle-orm/node-postgres";`
+  ].join("\n") : "";
+  const joinTables = Array.from(
+    new Set(
+      Array.from(hasManyByCollection.values()).flat().map((d) => d.joinTable)
+    )
+  ).sort();
+  const joinTableImports = joinTables.length > 0 ? `import { ${joinTables.join(", ")} } from "./collections";` : "";
+  const imports = [coreImports, drizzleImports, joinTableImports].filter(Boolean).join("\n");
+  const interfaces = collections.map((c) => renderCollectionInterface(c)).join("\n\n");
+  const helpers = collections.map((c) => renderReadHelpers(c, hasManyByCollection.get(c.slug) ?? [])).join("\n\n");
+  return [imports, "", interfaces, "", helpers, ""].join("\n");
+}
+function renderReadHelpers(collection, hasMany) {
+  const docType = `${toPascalCase2(collection.slug)}Document`;
+  const findFnName = `find${toPascalCase2(collection.slug)}`;
+  const getFnName = `get${toPascalCase2(collection.slug)}Document`;
+  const slug = JSON.stringify(collection.slug);
+  const findFn = hasMany.length === 0 ? renderSimpleFindFn(findFnName, slug, docType, collection.slug) : renderHasManyFindFn(findFnName, slug, docType, collection.slug, hasMany);
+  return [
+    findFn,
+    "",
+    `/** Typed by-id fetch for the \`${collection.slug}\` collection. */`,
+    `export function ${getFnName}(`,
+    `  id: string,`,
+    `  user?: NpAuthUser,`,
+    `): Promise<${docType} | null> {`,
+    `  return getDocumentById<${docType}>(${slug}, id, user);`,
+    `}`
+  ].join("\n");
+}
+function renderSimpleFindFn(findFnName, slug, docType, slugLabel) {
+  return [
+    `/** Typed listing query for the \`${slugLabel}\` collection. */`,
+    `export function ${findFnName}(`,
+    `  options: NpFindOptions<${docType}> = {},`,
+    `  user?: NpAuthUser,`,
+    `): Promise<NpFindResult<${docType}>> {`,
+    `  return findDocuments<${docType}>(${slug}, options, user);`,
+    `}`
+  ].join("\n");
+}
+function renderHasManyFindFn(findFnName, slug, docType, slugLabel, hasMany) {
+  const descriptors = hasMany.map(
+    (d) => `    { field: ${JSON.stringify(d.fieldName)}, table: ${d.joinTable}, parent: ${d.joinTable}.${d.parentColumn} },`
+  ).join("\n");
+  return [
+    `/**`,
+    ` * Typed listing query for the \`${slugLabel}\` collection.`,
+    ` *`,
+    ` * Pre-resolves hasMany relationship filters in the where`,
+    ` * clause (${hasMany.map((d) => `\`${d.fieldName}\``).join(", ")}) by`,
+    ` * subquerying the join table for matching parent ids. Each`,
+    ` * field accepts a single target id (most common) or an array`,
+    ` * of target ids (OR semantics). Multiple hasMany filters`,
+    ` * intersect \u2014 \`where: { categories: catId, tags: tagId }\``,
+    ` * matches rows that have BOTH.`,
+    ` */`,
+    `export async function ${findFnName}(`,
+    `  options: NpFindOptions<${docType}> = {},`,
+    `  user?: NpAuthUser,`,
+    `): Promise<NpFindResult<${docType}>> {`,
+    `  const where = options.where ? { ...options.where } : {};`,
+    `  const hasManyDescriptors = [`,
+    descriptors,
+    `  ];`,
+    ``,
+    `  const matched: string[][] = [];`,
+    `  let touchedHasMany = false;`,
+    `  for (const { field, table, parent } of hasManyDescriptors) {`,
+    `    const value = (where as Record<string, unknown>)[field];`,
+    `    if (value === undefined) continue;`,
+    `    touchedHasMany = true;`,
+    `    delete (where as Record<string, unknown>)[field];`,
+    `    const targets = (Array.isArray(value) ? value : [value]).filter(`,
+    `      (v): v is string => typeof v === "string" && v.length > 0,`,
+    `    );`,
+    `    if (targets.length === 0) {`,
+    `      // Empty array short-circuits to no rows \u2014 match the`,
+    `      // pipeline's array-where semantics.`,
+    `      matched.push([]);`,
+    `      continue;`,
+    `    }`,
+    `    // Cast getDb() to NodePgDatabase so the drizzle builder`,
+    `    // chain (.select.from.where) carries proper return types.`,
+    `    // The empty-schema generic narrows the return shape away`,
+    `    // from any specific tables; the explicit \`{ id: string }[]\` `,
+    `    // cast at the end matches the projection.`,
+    `    const db = getDb() as unknown as NodePgDatabase<Record<string, never>>;`,
+    `    const rows = (await db`,
+    `      .select({ id: parent })`,
+    `      .from(table)`,
+    `      .where(inArray(table.targetId, targets))) as Array<{ id: string }>;`,
+    `    matched.push(rows.map((r) => r.id));`,
+    `  }`,
+    ``,
+    `  if (touchedHasMany) {`,
+    `    // Intersect across all hasMany filters. Empty intersection`,
+    `    // \u2192 return immediately; findDocuments would short-circuit`,
+    `    // on the empty-array where clause anyway, but the early`,
+    `    // exit saves a round-trip.`,
+    `    let ids = matched[0] ?? [];`,
+    `    for (let i = 1; i < matched.length; i++) {`,
+    `      const set = new Set(matched[i]);`,
+    `      ids = ids.filter((id) => set.has(id));`,
+    `    }`,
+    ``,
+    `    // Honor any pre-existing user id constraint. Without this,`,
+    `    // \`where: { id: someId, categories: catId }\` would silently`,
+    `    // drop the user's id filter and return every post in that`,
+    `    // category \u2014 a real foot-gun. Intersect instead.`,
+    `    const existingId = (where as Record<string, unknown>).id;`,
+    `    if (typeof existingId === "string") {`,
+    `      ids = ids.includes(existingId) ? [existingId] : [];`,
+    `    } else if (Array.isArray(existingId)) {`,
+    `      const allowed = new Set(`,
+    `        existingId.filter((v): v is string => typeof v === "string"),`,
+    `      );`,
+    `      ids = ids.filter((id) => allowed.has(id));`,
+    `    }`,
+    ``,
+    `    if (ids.length === 0) {`,
+    `      return {`,
+    `        docs: [],`,
+    `        totalDocs: 0,`,
+    `        totalPages: 0,`,
+    `        page: options.page ?? 1,`,
+    `        limit: options.limit ?? 20,`,
+    `        hasNextPage: false,`,
+    `        hasPrevPage: false,`,
+    `      };`,
+    `    }`,
+    `    (where as Record<string, unknown>).id = ids;`,
+    `  }`,
+    ``,
+    `  return findDocuments<${docType}>(${slug}, { ...options, where }, user);`,
+    `}`
+  ].join("\n");
+}
+function renderCollectionInterface(collection) {
+  const interfaceName = `${toPascalCase2(collection.slug)}Document`;
+  const fields = [
+    "id: string;",
+    'status: "draft" | "published" | "archived" | "pending";',
+    "createdAt: Date;",
+    "updatedAt: Date;",
+    "createdBy: string | null;",
+    "updatedBy: string | null;"
+  ];
+  if (collection.community?.memberWrite?.create) {
+    fields.push("memberAuthorId: string | null;");
+  }
+  if (collection.slugField) {
+    fields.push("slug: string;");
+  }
+  if (collection.versions?.drafts) {
+    fields.push('_status: "draft" | "published";');
+  }
+  fields.push(...renderFields(collection.fields));
+  return [`export interface ${interfaceName} {`, ...fields.map((field) => `  ${field}`), "}"].join("\n");
+}
+function renderFields(fields, prefix = []) {
+  const lines = [];
+  for (const field of fields) {
+    if (field.type === "row" || field.type === "collapsible") {
+      lines.push(...renderFields(field.fields, prefix));
+      continue;
+    }
+    const fieldName = field.type === "group" ? getPropertyName(prefix, field.name) : "";
+    if (field.type === "group") {
+      const groupType = renderObjectType(field.fields);
+      lines.push(`${fieldName}: ${applyNullability(groupType, field.required)};`);
+      continue;
+    }
+    const propertyName = getPropertyName(prefix, field.name);
+    const typeSource = getTypeSource(field);
+    lines.push(`${propertyName}: ${applyNullability(typeSource, field.required)};`);
+  }
+  return lines;
+}
+function renderObjectType(fields) {
+  const members = renderFields(fields).map((field) => `  ${field}`);
+  return [`{`, ...members, `}`].join("\n");
+}
+function getTypeSource(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "email":
+    case "select":
+    case "radio":
+      return "string";
+    case "number":
+      return "number";
+    case "checkbox":
+      return "boolean";
+    case "date":
+      return "Date";
+    case "upload":
+      return "string";
+    case "relationship":
+      return field.hasMany ? "string[]" : "string";
+    case "array":
+      return `Array<${renderObjectType(field.fields)}>`;
+    case "richText":
+    case "blocks":
+    case "json":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function applyNullability(typeSource, required) {
+  return required ? typeSource : `${typeSource} | null`;
+}
+function getPropertyName(prefix, name) {
+  if (prefix.length === 0) {
+    return toCamelCase2(name);
+  }
+  return `${prefix[0]}${prefix.slice(1).map(toPascalCase2).join("")}${toPascalCase2(name)}`;
+}
+function toCamelCase2(value) {
+  const parts = splitName2(value);
+  const [first = "", ...rest] = parts;
+  return `${first}${rest.map(toPascalCase2).join("")}`;
+}
+function toPascalCase2(value) {
+  return splitName2(value).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function splitName2(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).map((part) => part.toLowerCase()).filter(Boolean);
+}
+
+export {
+  createDbConnection,
+  generateDrizzleSchema,
+  generateTypeScript,
+  generateDocumentsModule
+};
+//# sourceMappingURL=chunk-TFJ4MKPH.js.map