pocketbase-zod-schema 0.1.2

package/dist/migration/utils/index.cjs

@@ -0,0 +1,672 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/migration/utils/pluralize.ts
+var SPECIAL_CASES = {
+  // Common irregular plurals
+  person: "people",
+  Person: "People",
+  child: "children",
+  Child: "Children",
+  man: "men",
+  Man: "Men",
+  woman: "women",
+  Woman: "Women",
+  tooth: "teeth",
+  Tooth: "Teeth",
+  foot: "feet",
+  Foot: "Feet",
+  mouse: "mice",
+  Mouse: "Mice",
+  goose: "geese",
+  Goose: "Geese",
+  // Words ending in -y
+  category: "categories",
+  Category: "Categories",
+  company: "companies",
+  Company: "Companies",
+  city: "cities",
+  City: "Cities",
+  country: "countries",
+  Country: "Countries",
+  story: "stories",
+  Story: "Stories",
+  party: "parties",
+  Party: "Parties",
+  family: "families",
+  Family: "Families",
+  activity: "activities",
+  Activity: "Activities",
+  priority: "priorities",
+  Priority: "Priorities",
+  // Words ending in -f or -fe
+  life: "lives",
+  Life: "Lives",
+  wife: "wives",
+  Wife: "Wives",
+  knife: "knives",
+  Knife: "Knives",
+  leaf: "leaves",
+  Leaf: "Leaves",
+  shelf: "shelves",
+  Shelf: "Shelves",
+  half: "halves",
+  Half: "Halves",
+  // Words ending in -is
+  analysis: "analyses",
+  Analysis: "Analyses",
+  basis: "bases",
+  Basis: "Bases",
+  crisis: "crises",
+  Crisis: "Crises",
+  thesis: "theses",
+  Thesis: "Theses",
+  // Words ending in -us
+  cactus: "cacti",
+  Cactus: "Cacti",
+  focus: "foci",
+  Focus: "Foci",
+  fungus: "fungi",
+  Fungus: "Fungi",
+  nucleus: "nuclei",
+  Nucleus: "Nuclei",
+  radius: "radii",
+  Radius: "Radii",
+  // Words ending in -on
+  phenomenon: "phenomena",
+  Phenomenon: "Phenomena",
+  criterion: "criteria",
+  Criterion: "Criteria",
+  // Words ending in -um
+  datum: "data",
+  Datum: "Data",
+  medium: "media",
+  Medium: "Media",
+  curriculum: "curricula",
+  Curriculum: "Curricula",
+  // Unchanged plurals
+  sheep: "sheep",
+  Sheep: "Sheep",
+  deer: "deer",
+  Deer: "Deer",
+  fish: "fish",
+  Fish: "Fish",
+  species: "species",
+  Species: "Species",
+  series: "series",
+  Series: "Series"
+};
+function pluralize(singular) {
+  if (SPECIAL_CASES[singular]) {
+    return SPECIAL_CASES[singular];
+  }
+  if (singular.length > 3 && singular.endsWith("s") && !singular.endsWith("ss")) {
+    return singular;
+  }
+  const lowerSingular = singular.toLowerCase();
+  let plural;
+  if (/(?:s|ss|sh|ch|x|z)$/.test(lowerSingular)) {
+    plural = singular + "es";
+  } else if (/[^aeiou]y$/.test(lowerSingular)) {
+    plural = singular.slice(0, -1) + "ies";
+  } else if (/[^aeiou]o$/.test(lowerSingular)) {
+    plural = singular + "es";
+  } else if (/fe?$/.test(lowerSingular)) {
+    if (lowerSingular.endsWith("fe")) {
+      plural = singular.slice(0, -2) + "ves";
+    } else {
+      plural = singular.slice(0, -1) + "ves";
+    }
+  } else {
+    plural = singular + "s";
+  }
+  return plural;
+}
+function toCollectionName(entityName) {
+  return pluralize(entityName);
+}
+function singularize(plural) {
+  for (const [singular, pluralForm] of Object.entries(SPECIAL_CASES)) {
+    if (pluralForm === plural) {
+      return singular;
+    }
+  }
+  const lower = plural.toLowerCase();
+  if (lower.endsWith("ies") && plural.length > 3) {
+    return plural.slice(0, -3) + "y";
+  }
+  if (lower.endsWith("ves")) {
+    return plural.slice(0, -3) + "fe";
+  }
+  if (/(?:ses|shes|ches|xes|zes)$/.test(lower)) {
+    return plural.slice(0, -2);
+  }
+  if (lower.endsWith("s") && plural.length > 1) {
+    return plural.slice(0, -1);
+  }
+  return plural;
+}
+function isSingleRelationField(fieldName, zodType) {
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (!(unwrappedType instanceof zod.z.ZodString)) {
+    return false;
+  }
+  const startsWithUppercase = /^[A-Z]/.test(fieldName);
+  const commonStringFields = ["Title", "Name", "Description", "Content", "Summary", "Status", "Type"];
+  const isCommonField = commonStringFields.includes(fieldName);
+  return startsWithUppercase && !isCommonField;
+}
+function isMultipleRelationField(fieldName, zodType) {
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (!(unwrappedType instanceof zod.z.ZodArray)) {
+    return false;
+  }
+  const elementType = unwrappedType._def.type;
+  if (!(elementType instanceof zod.z.ZodString)) {
+    return false;
+  }
+  const hasUppercase = /[A-Z]/.test(fieldName);
+  return hasUppercase;
+}
+function resolveTargetCollection(fieldName) {
+  const matches = fieldName.match(/[A-Z][a-z]+/g);
+  if (!matches || matches.length === 0) {
+    return pluralize(fieldName);
+  }
+  const entityName = matches[matches.length - 1];
+  return pluralize(entityName);
+}
+function isRelationField(fieldName, zodType) {
+  return isSingleRelationField(fieldName, zodType) || isMultipleRelationField(fieldName, zodType);
+}
+function getMaxSelect(fieldName, zodType) {
+  if (isSingleRelationField(fieldName, zodType)) {
+    return 1;
+  }
+  if (isMultipleRelationField(fieldName, zodType)) {
+    let unwrappedType = zodType;
+    if (zodType instanceof zod.z.ZodOptional) {
+      unwrappedType = zodType._def.innerType;
+    }
+    if (unwrappedType instanceof zod.z.ZodNullable) {
+      unwrappedType = unwrappedType._def.innerType;
+    }
+    if (unwrappedType instanceof zod.z.ZodDefault) {
+      unwrappedType = unwrappedType._def.innerType;
+    }
+    if (unwrappedType instanceof zod.z.ZodArray) {
+      const arrayDef = unwrappedType._def;
+      if (arrayDef.maxLength) {
+        return arrayDef.maxLength.value;
+      }
+      return 999;
+    }
+  }
+  return 1;
+}
+function getMinSelect(fieldName, zodType) {
+  if (!isMultipleRelationField(fieldName, zodType)) {
+    return void 0;
+  }
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodArray) {
+    const arrayDef = unwrappedType._def;
+    if (arrayDef.minLength) {
+      return arrayDef.minLength.value;
+    }
+  }
+  return void 0;
+}
+var POCKETBASE_FIELD_TYPES = [
+  "text",
+  "email",
+  "url",
+  "number",
+  "bool",
+  "date",
+  "select",
+  "relation",
+  "file",
+  "json",
+  "editor",
+  "geoPoint",
+  "autodate"
+];
+var FIELD_TYPE_INFO = {
+  text: {
+    type: "text",
+    description: "Plain text field",
+    zodTypes: ["ZodString"],
+    supportsMultiple: false
+  },
+  email: {
+    type: "email",
+    description: "Email address field with validation",
+    zodTypes: ["ZodString with email()"],
+    supportsMultiple: false
+  },
+  url: {
+    type: "url",
+    description: "URL field with validation",
+    zodTypes: ["ZodString with url()"],
+    supportsMultiple: false
+  },
+  editor: {
+    type: "editor",
+    description: "Rich text editor field",
+    zodTypes: ["ZodString"],
+    supportsMultiple: false
+  },
+  number: {
+    type: "number",
+    description: "Numeric field (integer or float)",
+    zodTypes: ["ZodNumber"],
+    supportsMultiple: false
+  },
+  bool: {
+    type: "bool",
+    description: "Boolean field",
+    zodTypes: ["ZodBoolean"],
+    supportsMultiple: false
+  },
+  date: {
+    type: "date",
+    description: "Date/datetime field",
+    zodTypes: ["ZodDate", "ZodString with datetime format"],
+    supportsMultiple: false
+  },
+  autodate: {
+    type: "autodate",
+    description: "Auto-managed date field (created/updated)",
+    zodTypes: ["ZodString"],
+    supportsMultiple: false
+  },
+  select: {
+    type: "select",
+    description: "Single or multiple select from predefined values",
+    zodTypes: ["ZodEnum", "ZodArray<ZodEnum>"],
+    supportsMultiple: true
+  },
+  relation: {
+    type: "relation",
+    description: "Reference to another collection",
+    zodTypes: ["ZodString", "ZodArray<ZodString>"],
+    supportsMultiple: true
+  },
+  file: {
+    type: "file",
+    description: "File upload field",
+    zodTypes: ["File", "ZodArray<File>"],
+    supportsMultiple: true
+  },
+  json: {
+    type: "json",
+    description: "JSON data field",
+    zodTypes: ["ZodRecord", "ZodObject", "ZodArray"],
+    supportsMultiple: false
+  },
+  geoPoint: {
+    type: "geoPoint",
+    description: "Geographic coordinates (lon, lat)",
+    zodTypes: ["ZodObject with lon/lat"],
+    supportsMultiple: false
+  }
+};
+function mapZodStringType(zodType) {
+  const checks = zodType._def.checks || [];
+  const hasEmail = checks.some((check) => check.kind === "email");
+  if (hasEmail) {
+    return "email";
+  }
+  const hasUrl = checks.some((check) => check.kind === "url");
+  if (hasUrl) {
+    return "url";
+  }
+  const hasDatetime = checks.some((check) => check.kind === "datetime");
+  if (hasDatetime) {
+    return "date";
+  }
+  return "text";
+}
+function mapZodNumberType(_zodType) {
+  return "number";
+}
+function mapZodBooleanType(_zodType) {
+  return "bool";
+}
+function mapZodEnumType(_zodType) {
+  return "select";
+}
+function mapZodArrayType(zodType, _fieldName) {
+  const elementType = zodType._def.type;
+  if (elementType instanceof zod.z.ZodType) {
+    const typeName = elementType._def.typeName;
+    if (typeName === "ZodType" && elementType._def?.innerType?.name === "File") {
+      return "file";
+    }
+  }
+  if (elementType._def?.typeName === "ZodType") {
+    const checks = elementType._def?.checks || [];
+    const isFileInstance = checks.some(
+      (check) => check.kind === "instanceof" || elementType._def?.innerType?.name === "File"
+    );
+    if (isFileInstance) {
+      return "file";
+    }
+  }
+  if (elementType instanceof zod.z.ZodString) {
+    return "relation";
+  }
+  return "json";
+}
+function mapZodDateType(_zodType) {
+  return "date";
+}
+function mapZodRecordType(_zodType) {
+  return "json";
+}
+function mapZodTypeToPocketBase(zodType, fieldName) {
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType._def?.typeName === "ZodEffects") {
+    const effect = unwrappedType._def?.effect;
+    if (effect?.type === "refinement") {
+      const fileFieldNames = ["avatar", "image", "file", "attachment", "photo", "picture", "document", "upload"];
+      if (fileFieldNames.some((name) => fieldName.toLowerCase().includes(name))) {
+        return "file";
+      }
+    }
+  }
+  if (unwrappedType._def?.typeName === "ZodType") {
+    const checks = unwrappedType._def?.checks || [];
+    const innerType = unwrappedType._def?.innerType;
+    if (innerType?.name === "File" || checks.some((check) => check.kind === "instanceof")) {
+      return "file";
+    }
+  }
+  if (unwrappedType instanceof zod.z.ZodString) {
+    return mapZodStringType(unwrappedType);
+  }
+  if (unwrappedType instanceof zod.z.ZodNumber) {
+    return mapZodNumberType();
+  }
+  if (unwrappedType instanceof zod.z.ZodBoolean) {
+    return mapZodBooleanType();
+  }
+  if (unwrappedType instanceof zod.z.ZodEnum) {
+    return mapZodEnumType();
+  }
+  if (unwrappedType instanceof zod.z.ZodArray) {
+    return mapZodArrayType(unwrappedType);
+  }
+  if (unwrappedType instanceof zod.z.ZodDate) {
+    return mapZodDateType();
+  }
+  if (unwrappedType instanceof zod.z.ZodRecord || unwrappedType instanceof zod.z.ZodObject) {
+    return mapZodRecordType();
+  }
+  return "text";
+}
+function extractFieldOptions(zodType) {
+  const options = {};
+  let unwrappedType = zodType;
+  if (zodType instanceof zod.z.ZodOptional) {
+    unwrappedType = zodType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodNullable) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  if (unwrappedType instanceof zod.z.ZodDefault) {
+    unwrappedType = unwrappedType._def.innerType;
+  }
+  const checks = unwrappedType._def?.checks || [];
+  if (unwrappedType instanceof zod.z.ZodString) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+      if (check.kind === "regex") {
+        options.pattern = check.regex.source;
+      }
+    }
+  }
+  if (unwrappedType instanceof zod.z.ZodNumber) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+    }
+  }
+  if (unwrappedType instanceof zod.z.ZodEnum) {
+    options.values = unwrappedType._def.values;
+  }
+  if (unwrappedType instanceof zod.z.ZodArray) {
+    const arrayChecks = unwrappedType._def?.checks || [];
+    for (const check of arrayChecks) {
+      if (check.kind === "min") {
+        options.minSelect = check.value;
+      }
+      if (check.kind === "max") {
+        options.maxSelect = check.value;
+      }
+    }
+  }
+  return options;
+}
+function isFieldRequired(zodType) {
+  if (zodType instanceof zod.z.ZodOptional) {
+    return false;
+  }
+  if (zodType instanceof zod.z.ZodDefault) {
+    return false;
+  }
+  if (zodType instanceof zod.z.ZodNullable) {
+    return false;
+  }
+  return true;
+}
+function unwrapZodType(zodType) {
+  let unwrapped = zodType;
+  if (unwrapped instanceof zod.z.ZodOptional) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  if (unwrapped instanceof zod.z.ZodNullable) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  if (unwrapped instanceof zod.z.ZodDefault) {
+    unwrapped = unwrapped._def.innerType;
+  }
+  return unwrapped;
+}
+function getDefaultValue(zodType) {
+  if (zodType instanceof zod.z.ZodDefault) {
+    return zodType._def.defaultValue();
+  }
+  return void 0;
+}
+function isArrayType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  return unwrapped instanceof zod.z.ZodArray;
+}
+function getArrayElementType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  if (unwrapped instanceof zod.z.ZodArray) {
+    return unwrapped._def.type;
+  }
+  return null;
+}
+function isGeoPointType(zodType) {
+  const unwrapped = unwrapZodType(zodType);
+  if (!(unwrapped instanceof zod.z.ZodObject)) {
+    return false;
+  }
+  const shape = unwrapped._def.shape();
+  const hasLon = "lon" in shape && shape.lon instanceof zod.z.ZodNumber;
+  const hasLat = "lat" in shape && shape.lat instanceof zod.z.ZodNumber;
+  return hasLon && hasLat;
+}
+function extractComprehensiveFieldOptions(zodType) {
+  const options = {};
+  const unwrapped = unwrapZodType(zodType);
+  const checks = unwrapped._def?.checks || [];
+  if (unwrapped instanceof zod.z.ZodString) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+      if (check.kind === "regex") {
+        options.pattern = check.regex.source;
+      }
+    }
+  }
+  if (unwrapped instanceof zod.z.ZodNumber) {
+    for (const check of checks) {
+      if (check.kind === "min") {
+        options.min = check.value;
+      }
+      if (check.kind === "max") {
+        options.max = check.value;
+      }
+    }
+  }
+  if (unwrapped instanceof zod.z.ZodEnum) {
+    options.values = unwrapped._def.values;
+  }
+  if (unwrapped instanceof zod.z.ZodArray) {
+    const arrayDef = unwrapped._def;
+    if (arrayDef.minLength) {
+      options.minSelect = arrayDef.minLength.value;
+    }
+    if (arrayDef.maxLength) {
+      options.maxSelect = arrayDef.maxLength.value;
+    }
+    const elementType = arrayDef.type;
+    if (elementType instanceof zod.z.ZodEnum) {
+      options.values = elementType._def.values;
+    }
+  }
+  return options;
+}
+function isEditorField(fieldName) {
+  const editorFieldNames = [
+    "content",
+    "body",
+    "description",
+    "bio",
+    "about",
+    "summary",
+    "notes",
+    "details",
+    "html",
+    "richtext",
+    "editor"
+  ];
+  return editorFieldNames.some((name) => fieldName.toLowerCase().includes(name));
+}
+function isFileFieldByName(fieldName) {
+  const fileFieldNames = [
+    "avatar",
+    "image",
+    "file",
+    "attachment",
+    "photo",
+    "picture",
+    "document",
+    "upload",
+    "thumbnail",
+    "cover",
+    "banner",
+    "logo",
+    "icon",
+    "media"
+  ];
+  return fileFieldNames.some((name) => fieldName.toLowerCase().includes(name));
+}
+function getFieldTypeInfo(zodType, fieldName) {
+  const type = mapZodTypeToPocketBase(zodType, fieldName);
+  const isMultiple = isArrayType(zodType);
+  const options = extractComprehensiveFieldOptions(zodType);
+  return {
+    type,
+    isMultiple,
+    options
+  };
+}
+
+exports.FIELD_TYPE_INFO = FIELD_TYPE_INFO;
+exports.POCKETBASE_FIELD_TYPES = POCKETBASE_FIELD_TYPES;
+exports.extractComprehensiveFieldOptions = extractComprehensiveFieldOptions;
+exports.extractFieldOptions = extractFieldOptions;
+exports.getArrayElementType = getArrayElementType;
+exports.getDefaultValue = getDefaultValue;
+exports.getFieldTypeInfo = getFieldTypeInfo;
+exports.getMaxSelect = getMaxSelect;
+exports.getMinSelect = getMinSelect;
+exports.isArrayType = isArrayType;
+exports.isEditorField = isEditorField;
+exports.isFieldRequired = isFieldRequired;
+exports.isFileFieldByName = isFileFieldByName;
+exports.isGeoPointType = isGeoPointType;
+exports.isMultipleRelationField = isMultipleRelationField;
+exports.isRelationField = isRelationField;
+exports.isSingleRelationField = isSingleRelationField;
+exports.mapZodArrayType = mapZodArrayType;
+exports.mapZodBooleanType = mapZodBooleanType;
+exports.mapZodDateType = mapZodDateType;
+exports.mapZodEnumType = mapZodEnumType;
+exports.mapZodNumberType = mapZodNumberType;
+exports.mapZodRecordType = mapZodRecordType;
+exports.mapZodStringType = mapZodStringType;
+exports.mapZodTypeToPocketBase = mapZodTypeToPocketBase;
+exports.pluralize = pluralize;
+exports.resolveTargetCollection = resolveTargetCollection;
+exports.singularize = singularize;
+exports.toCollectionName = toCollectionName;
+exports.unwrapZodType = unwrapZodType;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map