@betterstart/cli 0.1.0

package/dist/core/index.js

@@ -0,0 +1,906 @@
+import {
+  quotePropertyName,
+  singularize,
+  toPascalCase
+} from "../chunk-GEH43BA4.js";
+import "../chunk-PWRI4LKM.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