@betterstart/cli 0.1.3 → 0.1.5

package/dist/core/index.js

@@ -1,906 +0,0 @@
-import {
-  quotePropertyName,
-  singularize,
-  toPascalCase
-} from "../chunk-EIH4RRIJ.js";
-import "../chunk-NKRQYAS6.js";
-import {
-  CodegenError,
-  ConfigurationError,
-  ERROR_CODES,
-  FileOperationError,
-  GeneratorError,
-  MissingFieldError,
-  PluginError,
-  SchemaValidationError,
-  UnsupportedFieldTypeError,
-  createBufferedLogger,
-  createConsoleLogger,
-  createSilentLogger,
-  getLogger,
-  isCodegenError,
-  logger,
-  resetLogger,
-  setLogger,
-  wrapError
-} from "../chunk-WY6BC55D.js";
-
-// src/core/constants.ts
-var FIELD_TYPES = {
-  // Primitives
-  STRING: "string",
-  NUMBER: "number",
-  BOOLEAN: "boolean",
-  TEXT: "text",
-  DECIMAL: "decimal",
-  VARCHAR: "varchar",
-  SERIAL: "serial",
-  // Date/Time
-  DATE: "date",
-  TIMESTAMP: "timestamp",
-  TIME: "time",
-  // Rich content
-  MARKDOWN: "markdown",
-  IMAGE: "image",
-  VIDEO: "video",
-  MEDIA: "media",
-  ICON: "icon",
-  // Structure
-  GROUP: "group",
-  TABS: "tabs",
-  LIST: "list",
-  SEPARATOR: "separator",
-  // Relations
-  SELECT: "select",
-  RELATIONSHIP: "relationship",
-  // Complex content types
-  CURRICULUM: "curriculum"
-};
-var NESTED_FIELD_TYPES = [FIELD_TYPES.GROUP, FIELD_TYPES.TABS, FIELD_TYPES.LIST];
-var RICH_TEXT_FIELD_TYPES = [FIELD_TYPES.MARKDOWN, FIELD_TYPES.TEXT];
-var LONG_TEXT_FIELD_TYPES = [
-  FIELD_TYPES.TEXT,
-  FIELD_TYPES.MARKDOWN,
-  FIELD_TYPES.LIST,
-  FIELD_TYPES.MEDIA,
-  FIELD_TYPES.VIDEO,
-  FIELD_TYPES.CURRICULUM
-];
-var COLUMN_TYPES = {
-  TEXT: "text",
-  BADGE: "badge",
-  DATE: "date",
-  CUSTOM: "custom",
-  AVATAR: "avatar",
-  LINK: "link",
-  IMAGE: "image",
-  EMAIL: "email",
-  NUMBER: "number",
-  BOOLEAN: "boolean"
-};
-var FORM_FIELD_TYPES = {
-  TEXT: "text",
-  TEXTAREA: "textarea",
-  EMAIL: "email",
-  PHONE: "phone",
-  NUMBER: "number",
-  URL: "url",
-  DATE: "date",
-  SELECT: "select",
-  RADIO: "radio",
-  CHECKBOX: "checkbox",
-  MULTISELECT: "multiselect",
-  FILE: "file",
-  UPLOAD: "upload",
-  GROUP: "group",
-  TIMEZONE: "timezone",
-  LIST: "list"
-};
-var AUTO_FIELDS = {
-  ID: "id",
-  CREATED_AT: "createdAt",
-  UPDATED_AT: "updatedAt",
-  PUBLISHED: "published",
-  SLUG: "slug"
-};
-var FORM_SUBMISSION_FIELDS = {
-  SUBMITTED_AT: "submittedAt",
-  IP_ADDRESS: "ipAddress",
-  USER_AGENT: "userAgent"
-};
-var DRIZZLE_DEFAULTS = {
-  VARCHAR_LENGTH: 255,
-  DECIMAL_PRECISION: 10,
-  DECIMAL_SCALE: 2
-};
-var CORE_GENERATORS = [
-  "database",
-  "actions",
-  "hooks",
-  "columns",
-  "table",
-  "page",
-  "page-content",
-  "form",
-  "create-page",
-  "edit-page",
-  "navigation"
-];
-var OPTIONAL_GENERATORS = [];
-var FILE_EXTENSIONS = {
-  TYPESCRIPT: ".ts",
-  TSX: ".tsx",
-  JSON: ".json",
-  SQL: ".sql"
-};
-function isFieldType(value) {
-  return Object.values(FIELD_TYPES).includes(value);
-}
-function isNestedFieldType(type) {
-  return NESTED_FIELD_TYPES.includes(type);
-}
-function isLongTextFieldType(type) {
-  return LONG_TEXT_FIELD_TYPES.includes(type);
-}
-
-// src/core/field-helpers.ts
-var DEFAULT_WALK_OPTIONS = {
-  includeLists: true,
-  includeGroups: true,
-  includeTabs: true
-};
-function walkFields(fields, callback, options = DEFAULT_WALK_OPTIONS) {
-  function walk(fieldsToWalk, depth, parent) {
-    for (const field of fieldsToWalk) {
-      callback(field, depth, parent);
-      if (options.includeGroups && field.type === "group" && field.fields) {
-        walk(field.fields, depth + 1, field);
-      }
-      if (options.includeLists && field.type === "list" && field.fields) {
-        walk(field.fields, depth + 1, field);
-      }
-      if (options.includeTabs && field.type === "tabs" && field.tabs) {
-        for (const tab of field.tabs) {
-          if (tab.fields) {
-            walk(tab.fields, depth + 1, field);
-          }
-        }
-      }
-    }
-  }
-  walk(fields, 0);
-}
-function hasFieldType(fields, type, options) {
-  let found = false;
-  walkFields(
-    fields,
-    (field) => {
-      if (field.type === type) {
-        found = true;
-      }
-    },
-    options
-  );
-  return found;
-}
-function hasAnyFieldType(fields, types, options) {
-  let found = false;
-  walkFields(
-    fields,
-    (field) => {
-      if (types.includes(field.type)) {
-        found = true;
-      }
-    },
-    options
-  );
-  return found;
-}
-function hasIconUsage(fields, options) {
-  let found = false;
-  walkFields(
-    fields,
-    (field) => {
-      if (field.type === "icon" || field.hasIcon) {
-        found = true;
-      }
-    },
-    options
-  );
-  return found;
-}
-function hasRelationshipField(fields, options) {
-  return hasFieldType(fields, FIELD_TYPES.RELATIONSHIP, options);
-}
-function hasMarkdownField(fields, options) {
-  return hasFieldType(fields, FIELD_TYPES.MARKDOWN, options);
-}
-function hasTextareaField(fields, options) {
-  return hasFieldType(fields, FIELD_TYPES.TEXT, options);
-}
-function collectFieldsByType(fields, type, options) {
-  const result = [];
-  walkFields(
-    fields,
-    (field) => {
-      if (field.type === type) {
-        result.push(field);
-      }
-    },
-    options
-  );
-  return result;
-}
-function getManyToManyFields(fields) {
-  const flat = flattenFields(fields);
-  return flat.filter((f) => f.type === "relationship" && f.multiple === true && f.relationship);
-}
-function getNestedRelationshipFields(fields, options) {
-  const result = [];
-  walkFields(
-    fields,
-    (field) => {
-      if (field.type === "relationship" && field.relationship && !field.multiple) {
-        result.push(field);
-      }
-    },
-    options
-  );
-  return result;
-}
-function collectRelationshipFieldsTopLevel(fields) {
-  const result = [];
-  function collect(fieldsToCheck) {
-    for (const f of fieldsToCheck) {
-      if (f.type === "relationship" && f.relationship) {
-        result.push(f);
-      }
-      if (f.type === "group" && f.fields) {
-        collect(f.fields);
-      }
-    }
-  }
-  collect(fields);
-  return result;
-}
-function collectAllRelationshipFields(fields) {
-  return collectFieldsByType(fields, FIELD_TYPES.RELATIONSHIP);
-}
-function getListFieldsWithNestedFields(fields) {
-  const result = [];
-  function collect(fieldsToCheck) {
-    for (const f of fieldsToCheck) {
-      if (f.type === "list" && f.fields && f.fields.length > 0) {
-        result.push(f);
-      }
-      if (f.type === "group" && f.fields) {
-        collect(f.fields);
-      }
-    }
-  }
-  collect(fields);
-  return result;
-}
-function getNestedListFields(fields) {
-  const result = [];
-  const listFields = getListFieldsWithNestedFields(fields);
-  for (const parent of listFields) {
-    if (parent.fields) {
-      for (const nested of parent.fields) {
-        if (nested.type === "list" && nested.fields && nested.fields.length > 0) {
-          result.push({ parent, nested });
-        }
-      }
-    }
-  }
-  return result;
-}
-var AUTO_ID_FIELD = {
-  name: "id",
-  type: "serial",
-  primaryKey: true
-};
-function ensureIdField(fields) {
-  const hasIdField = fields.some((f) => f.primaryKey || f.name === "id");
-  if (hasIdField) {
-    return fields;
-  }
-  return [AUTO_ID_FIELD, ...fields];
-}
-function flattenFields(fields) {
-  const fieldsWithId = ensureIdField(fields);
-  return flattenFieldsWithoutIdCheck(fieldsWithId);
-}
-function flattenFieldsWithoutIdCheck(fields) {
-  const flattened = [];
-  for (const field of fields) {
-    if (field.type === "group" && field.fields) {
-      flattened.push(...flattenFieldsWithoutIdCheck(field.fields));
-    } else if (field.type === "tabs" && field.tabs) {
-      for (const tab of field.tabs) {
-        if (tab.fields) {
-          flattened.push(...flattenFieldsWithoutIdCheck(tab.fields));
-        }
-      }
-    } else {
-      flattened.push(field);
-    }
-  }
-  return flattened;
-}
-function getAllFormFields(schema) {
-  const allFields = [];
-  if (schema.steps) {
-    for (const step of schema.steps) {
-      for (const field of step.fields) {
-        if (field.type === "group" && field.fields) {
-          for (const nestedField of field.fields) {
-            allFields.push({
-              ...nestedField,
-              condition: nestedField.condition || field.condition
-            });
-          }
-        } else {
-          allFields.push(field);
-        }
-      }
-    }
-  } else if (schema.fields) {
-    for (const field of schema.fields) {
-      if (field.type === "group" && field.fields) {
-        for (const nestedField of field.fields) {
-          allFields.push({
-            ...nestedField,
-            condition: nestedField.condition || field.condition
-          });
-        }
-      } else {
-        allFields.push(field);
-      }
-    }
-  }
-  return allFields;
-}
-function isMultiStepForm(schema) {
-  return Array.isArray(schema.steps) && schema.steps.length > 0;
-}
-function analyzeFields(fields) {
-  const fieldTypes = /* @__PURE__ */ new Set();
-  let hasIcon = false;
-  let hasNestedList = false;
-  walkFields(fields, (field) => {
-    fieldTypes.add(field.type);
-    if (field.type === "icon" || field.hasIcon) {
-      hasIcon = true;
-    }
-  });
-  const listFields = getListFieldsWithNestedFields(fields);
-  for (const listField of listFields) {
-    if (listField.fields?.some((f) => f.type === "list")) {
-      hasNestedList = true;
-      break;
-    }
-  }
-  return {
-    hasBoolean: fieldTypes.has(FIELD_TYPES.BOOLEAN),
-    hasImage: fieldTypes.has(FIELD_TYPES.IMAGE),
-    hasVideo: fieldTypes.has(FIELD_TYPES.VIDEO),
-    hasMedia: fieldTypes.has(FIELD_TYPES.MEDIA),
-    hasDate: fieldTypes.has(FIELD_TYPES.DATE),
-    hasList: fieldTypes.has(FIELD_TYPES.LIST),
-    hasNestedList,
-    hasSelect: fieldTypes.has(FIELD_TYPES.SELECT),
-    hasMarkdown: fieldTypes.has(FIELD_TYPES.MARKDOWN),
-    hasTextarea: fieldTypes.has(FIELD_TYPES.TEXT),
-    hasSeparator: fieldTypes.has(FIELD_TYPES.SEPARATOR),
-    hasIcon,
-    hasRelationship: fieldTypes.has(FIELD_TYPES.RELATIONSHIP),
-    hasManyToMany: getManyToManyFields(fields).length > 0,
-    fieldTypes
-  };
-}
-
-// src/core/type-mappers.ts
-function isUrlField(fieldName) {
-  const urlKeywords = ["url", "link", "href", "website", "avatar", "logo", "thumbnail"];
-  const lowerName = fieldName.toLowerCase();
-  return urlKeywords.some((keyword) => lowerName.includes(keyword));
-}
-function toDrizzleType(field, requiredImports) {
-  switch (field.type) {
-    case "serial":
-      requiredImports.add("serial");
-      return "serial()";
-    case "string":
-    case "varchar":
-      if (isUrlField(field.name) && !field.length) {
-        requiredImports.add("text");
-        return "text()";
-      }
-      requiredImports.add("varchar");
-      return field.length ? `varchar({ length: ${field.length} })` : `varchar({ length: ${DRIZZLE_DEFAULTS.VARCHAR_LENGTH} })`;
-    case "image":
-    case "video":
-    case "media":
-      requiredImports.add("text");
-      return "text()";
-    case "text":
-    case "markdown":
-    case "richtext":
-      requiredImports.add("text");
-      return "text()";
-    case "number":
-      requiredImports.add("integer");
-      return "integer()";
-    case "decimal":
-      requiredImports.add("decimal");
-      if (field.precision && field.scale) {
-        return `decimal({ precision: ${field.precision}, scale: ${field.scale} })`;
-      }
-      return `decimal({ precision: ${DRIZZLE_DEFAULTS.DECIMAL_PRECISION}, scale: ${DRIZZLE_DEFAULTS.DECIMAL_SCALE} })`;
-    case "boolean":
-      requiredImports.add("boolean");
-      return "boolean()";
-    case "timestamp":
-      requiredImports.add("timestamp");
-      return "timestamp({ precision: 3, mode: 'string' })";
-    case "date":
-      requiredImports.add("date");
-      return "date({ mode: 'string' })";
-    case "time":
-    case "select":
-    case "icon":
-      requiredImports.add("varchar");
-      return field.length ? `varchar({ length: ${field.length} })` : `varchar({ length: ${DRIZZLE_DEFAULTS.VARCHAR_LENGTH} })`;
-    case "curriculum":
-      requiredImports.add("jsonb");
-      return `jsonb().$type<{ mode: 'sequential'; items: Array<{ title?: string; description?: string }> } | { mode: 'weekly'; weeks: Array<{ weekNumber: number; weekTitle?: string; weekDescription?: string; durationHours?: number; items: Array<{ title?: string; description?: string }> }> }>()`;
-    case "list":
-      requiredImports.add("jsonb");
-      if (field.fields && field.fields.length > 0) {
-        const nestedType = buildNestedListType(field.fields);
-        return `jsonb().$type<Array<{ ${nestedType} }>>()`;
-      }
-      return "jsonb().$type<string[]>()";
-    case "relationship":
-      requiredImports.add("integer");
-      return "integer()";
-    default:
-      requiredImports.add("text");
-      return "text()";
-  }
-}
-function buildNestedListType(fields) {
-  return fields.flatMap((f) => {
-    let type;
-    if (f.type === "list" && f.fields && f.fields.length > 0) {
-      const innerType = f.fields.map((nf) => {
-        let nfType;
-        if (nf.type === "boolean") {
-          nfType = "boolean";
-        } else if (nf.type === "number" || nf.type === "decimal") {
-          nfType = "number";
-        } else {
-          nfType = "string";
-        }
-        return `${quotePropertyName(nf.name)}?: ${nfType}`;
-      }).join("; ");
-      type = `Array<{ ${innerType} }>`;
-    } else if (f.type === "list") {
-      type = "string[]";
-    } else if (f.type === "number" || f.type === "decimal") {
-      type = "number";
-    } else if (f.type === "boolean") {
-      type = "boolean";
-    } else {
-      type = "string";
-    }
-    const result = [`${quotePropertyName(f.name)}?: ${type}`];
-    if (f.hasIcon) {
-      result.push(`${quotePropertyName(`${f.name}Icon`)}?: string`);
-    }
-    return result;
-  }).join("; ");
-}
-function toZodType(field) {
-  const label = field.label || field.name;
-  switch (field.type) {
-    case "serial":
-    case "number":
-    case "decimal":
-      return field.required ? `z.number({ message: '${label} is required' })` : "z.number().optional()";
-    case "boolean":
-      return "z.boolean()";
-    case "string":
-    case "varchar":
-    case "text":
-    case "markdown":
-    case "richtext": {
-      if (field.name.toLowerCase().includes("email")) {
-        const base2 = field.required ? `z.string().min(1, '${label} is required').email('Please enter a valid email address')` : `z.string().email('Please enter a valid email address').optional()`;
-        return field.length ? `${base2}.max(${field.length})` : base2;
-      }
-      const base = field.required ? `z.string().min(1, '${label} is required')` : "z.string()";
-      return field.length ? `${base}.max(${field.length})` : base;
-    }
-    case "date":
-      if (!field.required) {
-        return 'z.string().transform(val => val === "" ? undefined : val).optional()';
-      }
-      return `z.string().min(1, '${label} is required')`;
-    case "timestamp":
-      return field.required ? `z.string().min(1, '${label} is required')` : "z.string().optional()";
-    case "image":
-    case "video":
-    case "media": {
-      if (!field.required) {
-        return 'z.string().transform(val => val === "" ? undefined : val).optional()';
-      }
-      const mediaType = field.type === "image" ? "an image" : field.type === "video" ? "a video" : "media";
-      const base = `z.string().min(1, 'Please upload ${mediaType} for ${label}').url('Please provide a valid ${field.type} URL')`;
-      return field.length ? `${base}.max(${field.length})` : base;
-    }
-    case "list":
-      return buildZodListType(field, label);
-    case "select": {
-      if (field.options && field.options.length > 0) {
-        const values = field.options.map((opt) => `'${opt.value}'`).join(", ");
-        const valuesArray = `[${values}] as const`;
-        return field.required ? `z.string().min(1, '${label} is required').refine((val) => (${valuesArray} as readonly string[]).includes(val), { message: 'Invalid ${label}' })` : `z.string().refine((val) => !val || (${valuesArray} as readonly string[]).includes(val), { message: 'Invalid ${label}' }).optional()`;
-      }
-      return field.required ? `z.string().min(1, '${label} is required')` : "z.string().optional()";
-    }
-    case "icon":
-      return field.required ? `z.string().min(1, '${label} is required')` : "z.string().optional()";
-    case "relationship": {
-      if (field.multiple) {
-        return field.required ? `z.array(z.number()).min(1, '${label} is required')` : "z.array(z.number()).optional()";
-      }
-      return field.required ? `z.string().min(1, '${label} is required')` : "z.string().optional()";
-    }
-    case "curriculum":
-      return `z.object({
-    mode: z.enum(['sequential', 'weekly']),
-    items: z.array(z.object({
-      title: z.string().max(255).optional(),
-      description: z.string().max(500).optional()
-    })).max(50),
-    weeks: z.array(z.object({
-      weekNumber: z.number().int().positive(),
-      weekTitle: z.string().max(100).optional(),
-      weekDescription: z.string().max(1000).optional(),
-      durationHours: z.number().positive().optional(),
-      items: z.array(z.object({
-        title: z.string().max(255).optional(),
-        description: z.string().max(500).optional()
-      })).max(20)
-    })).max(20)
-  }).optional()`;
-    default:
-      return field.required ? `z.string().min(1, '${label} is required')` : "z.string().optional()";
-  }
-}
-function buildZodListType(field, label) {
-  if (field.fields && field.fields.length > 0) {
-    const nestedFields = field.fields.flatMap((nestedField) => {
-      const defs = [];
-      const nestedZodType = toZodType(nestedField);
-      const alreadyOptional = nestedZodType.includes(".optional()");
-      let nestedDef = `    ${quotePropertyName(nestedField.name)}: ${nestedZodType}`;
-      if (!nestedField.required && !alreadyOptional) {
-        nestedDef += ".optional()";
-      }
-      defs.push(nestedDef);
-      if (nestedField.hasIcon) {
-        defs.push(`    ${quotePropertyName(`${nestedField.name}Icon`)}: z.string().optional()`);
-      }
-      return defs;
-    }).join(",\n");
-    const objectSchema = `z.object({
-${nestedFields}
-  })`;
-    const arraySchema = field.maxItems ? `z.array(${objectSchema}).max(${field.maxItems}, '${label} cannot exceed ${field.maxItems} items')` : `z.array(${objectSchema})`;
-    return field.required ? `${arraySchema}.min(1, '${label} must have at least one item')` : `${arraySchema}.optional()`;
-  }
-  if (field.items?.type === "string" || field.items?.type === "varchar") {
-    const itemSchema = field.items.length ? `z.string().max(${field.items.length})` : "z.string()";
-    const arraySchema = field.maxItems ? `z.array(${itemSchema}).max(${field.maxItems}, '${label} cannot exceed ${field.maxItems} items')` : `z.array(${itemSchema})`;
-    return field.required ? `${arraySchema}.min(1, '${label} must have at least one item')` : `${arraySchema}.optional()`;
-  }
-  return field.required ? `z.array(z.string()).min(1, '${label} must have at least one item')` : "z.array(z.string()).optional()";
-}
-function toTypeScriptType(field, mode = "output") {
-  switch (field.type) {
-    case "serial":
-    case "number":
-    case "decimal":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "string":
-    case "varchar":
-    case "text":
-    case "markdown":
-    case "richtext":
-    case "date":
-    case "time":
-    case "timestamp":
-    case "image":
-    case "video":
-    case "media":
-    case "icon":
-    case "select":
-      return "string";
-    case "relationship":
-      if (mode === "input") {
-        return field.multiple ? "number[]" : "string";
-      }
-      if (field.relationship) {
-        const relationshipSingular = singularize(field.relationship);
-        const relationshipPascal = toPascalCase(relationshipSingular);
-        return field.multiple ? `${relationshipPascal}Data[]` : `${relationshipPascal}Data | null`;
-      }
-      return "string";
-    case "list":
-      if (field.fields && field.fields.length > 0) {
-        const nestedType = field.fields.flatMap((f) => {
-          const type = toTypeScriptType(f, "input");
-          const fields = [`${quotePropertyName(f.name)}?: ${type}`];
-          if (f.hasIcon) {
-            fields.push(`${quotePropertyName(`${f.name}Icon`)}?: string`);
-          }
-          return fields;
-        }).join("; ");
-        return `Array<{ ${nestedType} }>`;
-      }
-      return "string[]";
-    case "curriculum":
-      return '{ mode: "sequential" | "weekly"; items: Array<{ title?: string; description?: string }>; weeks: Array<{ weekNumber: number; weekTitle?: string; weekDescription?: string; durationHours?: number; items: Array<{ title?: string; description?: string }> }> }';
-    default:
-      return "string";
-  }
-}
-function toFormFieldType(field) {
-  switch (field.type) {
-    case "boolean":
-      return "checkbox";
-    case "text":
-      return "textarea";
-    case "markdown":
-      return "markdown";
-    case "richtext":
-      return "richtext";
-    case "number":
-    case "decimal":
-      return "number";
-    case "date":
-      return "date";
-    case "time":
-      return "time";
-    case "timestamp":
-      return "datetime-local";
-    default:
-      return "text";
-  }
-}
-function formFieldToDrizzleType(field, requiredImports) {
-  switch (field.type) {
-    case "text":
-      requiredImports.add("varchar");
-      return field.maxLength ? `varchar({ length: ${field.maxLength} })` : `varchar({ length: ${DRIZZLE_DEFAULTS.VARCHAR_LENGTH} })`;
-    case "textarea":
-      requiredImports.add("text");
-      return "text()";
-    case "email":
-      requiredImports.add("varchar");
-      return `varchar({ length: ${DRIZZLE_DEFAULTS.VARCHAR_LENGTH} })`;
-    case "phone":
-      requiredImports.add("varchar");
-      return "varchar({ length: 50 })";
-    case "number":
-      requiredImports.add("integer");
-      return "integer()";
-    case "url":
-      requiredImports.add("varchar");
-      return "varchar({ length: 500 })";
-    case "date":
-      requiredImports.add("date");
-      return "date({ mode: 'string' })";
-    case "select":
-    case "radio":
-    case "timezone":
-      requiredImports.add("varchar");
-      return `varchar({ length: ${DRIZZLE_DEFAULTS.VARCHAR_LENGTH} })`;
-    case "checkbox":
-      requiredImports.add("boolean");
-      return "boolean()";
-    case "multiselect":
-      requiredImports.add("jsonb");
-      return "jsonb().$type<string[]>()";
-    case "list":
-      requiredImports.add("jsonb");
-      if (field.fields && field.fields.length > 0) {
-        return "jsonb().$type<Record<string, unknown>[]>()";
-      }
-      return "jsonb().$type<string[]>()";
-    case "file":
-    case "upload":
-      requiredImports.add("text");
-      return "text()";
-    default:
-      requiredImports.add("text");
-      return "text()";
-  }
-}
-function formFieldToZodType(field, options = {}) {
-  const label = field.label;
-  const isRequired = field.required && !options.treatAsOptional;
-  switch (field.type) {
-    case "text": {
-      let zodType = isRequired ? `z.string().min(1, '${label} is required')` : "z.string()";
-      if (field.minLength) {
-        zodType += `.min(${field.minLength}, '${label} must be at least ${field.minLength} characters')`;
-      }
-      if (field.maxLength) {
-        zodType += `.max(${field.maxLength}, '${label} must be at most ${field.maxLength} characters')`;
-      }
-      if (field.pattern) {
-        zodType += `.regex(new RegExp('${field.pattern}'), 'Invalid ${label} format')`;
-      }
-      return isRequired ? zodType : `${zodType}.optional()`;
-    }
-    case "textarea": {
-      let zodType = isRequired ? `z.string().min(1, '${label} is required')` : "z.string()";
-      if (field.minLength) {
-        zodType += `.min(${field.minLength}, '${label} must be at least ${field.minLength} characters')`;
-      }
-      if (field.maxLength) {
-        zodType += `.max(${field.maxLength}, '${label} must be at most ${field.maxLength} characters')`;
-      }
-      return isRequired ? zodType : `${zodType}.optional()`;
-    }
-    case "email":
-      return isRequired ? `z.string().min(1, '${label} is required').email('Please enter a valid email address')` : `z.string().optional().refine((val) => !val || val.trim() === '' || z.string().email().safeParse(val).success, { message: 'Please enter a valid email address' })`;
-    case "phone": {
-      const pattern = field.pattern || "^[+]?[(]?[0-9]{1,4}[)]?[-\\s\\.]?[(]?[0-9]{1,4}[)]?[-\\s\\.]?[0-9]{1,9}$";
-      return isRequired ? `z.string().min(1, '${label} is required').regex(new RegExp('${pattern}'), 'Please enter a valid phone number')` : `z.string().optional().refine((val) => !val || val.trim() === '' || new RegExp('${pattern}').test(val), { message: 'Please enter a valid phone number' })`;
-    }
-    case "number": {
-      let zodType = isRequired ? `z.number({ message: '${label} is required' })` : "z.number()";
-      if (field.min !== void 0) {
-        zodType += `.min(${field.min}, '${label} must be at least ${field.min}')`;
-      }
-      if (field.max !== void 0) {
-        zodType += `.max(${field.max}, '${label} must be at most ${field.max}')`;
-      }
-      return isRequired ? zodType : `${zodType}.optional()`;
-    }
-    case "url":
-      return isRequired ? `z.string().min(1, '${label} is required').url('Please enter a valid URL')` : `z.string().optional().refine((val) => !val || val.trim() === '' || z.string().url().safeParse(val).success, { message: 'Please enter a valid URL' })`;
-    case "date":
-      return isRequired ? `z.string().min(1, '${label} is required')` : 'z.string().transform(val => val === "" ? undefined : val).optional()';
-    case "select":
-    case "radio":
-      if (field.options && field.options.length > 0) {
-        const values = field.options.map((opt) => `'${opt.value}'`).join(", ");
-        return isRequired ? `z.enum([${values}], { message: '${label} is required' })` : `z.enum([${values}]).optional()`;
-      }
-      return isRequired ? `z.string().min(1, '${label} is required')` : "z.string().optional()";
-    case "checkbox":
-      return isRequired ? `z.literal(true, { message: '${label} is required' })` : "z.boolean().optional()";
-    case "multiselect":
-      return isRequired ? `z.array(z.string()).min(1, '${label} is required')` : "z.array(z.string()).optional()";
-    case "timezone":
-      return isRequired ? `z.string().min(1, '${label} is required')` : "z.string().optional()";
-    case "list":
-      if (field.fields && field.fields.length > 0) {
-        const nestedFields = field.fields.map((f) => `${f.name}: ${formFieldToZodType(f, options)}`).join(", ");
-        return isRequired ? `z.array(z.object({ ${nestedFields} })).min(1, '${label} is required')` : `z.array(z.object({ ${nestedFields} })).optional()`;
-      }
-      return isRequired ? `z.array(z.string()).min(1, '${label} is required')` : "z.array(z.string()).optional()";
-    case "file":
-    case "upload":
-      return isRequired ? `z.string().min(1, '${label} is required')` : "z.string().optional()";
-    default:
-      return isRequired ? `z.string().min(1, '${label} is required')` : "z.string().optional()";
-  }
-}
-function toSQLType(field) {
-  switch (field.type) {
-    case "serial":
-      return "SERIAL";
-    case "string":
-    case "varchar":
-      return field.length ? `VARCHAR(${field.length})` : `VARCHAR(${DRIZZLE_DEFAULTS.VARCHAR_LENGTH})`;
-    case "text":
-    case "markdown":
-    case "richtext":
-    case "image":
-    case "video":
-    case "media":
-      return "TEXT";
-    case "number":
-      return "INTEGER";
-    case "decimal":
-      return `DECIMAL(${field.precision || DRIZZLE_DEFAULTS.DECIMAL_PRECISION}, ${field.scale || DRIZZLE_DEFAULTS.DECIMAL_SCALE})`;
-    case "boolean":
-      return "BOOLEAN";
-    case "timestamp":
-      return "TIMESTAMP(3)";
-    case "date":
-      return "DATE";
-    case "time":
-    case "select":
-    case "icon":
-      return `VARCHAR(${DRIZZLE_DEFAULTS.VARCHAR_LENGTH})`;
-    case "list":
-    case "curriculum":
-      return "JSONB";
-    case "relationship":
-      return "INTEGER";
-    default:
-      return "TEXT";
-  }
-}
-export {
-  AUTO_FIELDS,
-  COLUMN_TYPES,
-  CORE_GENERATORS,
-  CodegenError,
-  ConfigurationError,
-  DRIZZLE_DEFAULTS,
-  ERROR_CODES,
-  FIELD_TYPES,
-  FILE_EXTENSIONS,
-  FORM_FIELD_TYPES,
-  FORM_SUBMISSION_FIELDS,
-  FileOperationError,
-  GeneratorError,
-  LONG_TEXT_FIELD_TYPES,
-  MissingFieldError,
-  NESTED_FIELD_TYPES,
-  OPTIONAL_GENERATORS,
-  PluginError,
-  RICH_TEXT_FIELD_TYPES,
-  SchemaValidationError,
-  UnsupportedFieldTypeError,
-  analyzeFields,
-  collectAllRelationshipFields,
-  collectFieldsByType,
-  collectRelationshipFieldsTopLevel,
-  createBufferedLogger,
-  createConsoleLogger,
-  createSilentLogger,
-  ensureIdField,
-  flattenFields,
-  formFieldToDrizzleType,
-  formFieldToZodType,
-  getAllFormFields,
-  getListFieldsWithNestedFields,
-  getLogger,
-  getManyToManyFields,
-  getNestedListFields,
-  getNestedRelationshipFields,
-  hasAnyFieldType,
-  hasFieldType,
-  hasIconUsage,
-  hasMarkdownField,
-  hasRelationshipField,
-  hasTextareaField,
-  isCodegenError,
-  isFieldType,
-  isLongTextFieldType,
-  isMultiStepForm,
-  isNestedFieldType,
-  logger,
-  resetLogger,
-  setLogger,
-  toDrizzleType,
-  toFormFieldType,
-  toSQLType,
-  toTypeScriptType,
-  toZodType,
-  walkFields,
-  wrapError
-};
-//# sourceMappingURL=index.js.map