pocketbase-zod-schema 0.2.5 → 0.3.0

package/dist/migration/utils/index.d.ts

@@ -1,209 +1,46 @@
-import { z } from 'zod';
-import { P as PocketBaseFieldType } from '../../fields-YjcpBXVp.js';
-export { F as FIELD_METADATA_KEY, a as FieldMetadata, e as extractFieldMetadata } from '../../fields-YjcpBXVp.js';
+export { E as ExtractedFieldOptions, d as FIELD_TYPE_INFO, F as FieldTypeInfo, C as FieldTypeResult, P as POCKETBASE_FIELD_TYPES, z as extractComprehensiveFieldOptions, o as extractFieldOptions, x as getArrayElementType, v as getDefaultValue, D as getFieldTypeInfo, g as getMaxSelect, c as getMinSelect, w as isArrayType, A as isEditorField, q as isFieldRequired, B as isFileFieldByName, y as isGeoPointType, a as isMultipleRelationField, b as isRelationField, i as isSingleRelationField, j as mapZodArrayType, f as mapZodBooleanType, k as mapZodDateType, h as mapZodEnumType, e as mapZodNumberType, l as mapZodRecordType, m as mapZodStringType, n as mapZodTypeToPocketBase, p as pluralize, r as resolveTargetCollection, s as singularize, t as toCollectionName, u as unwrapZodType } from '../../type-mapper-n231Fspm.js';
+export { F as FIELD_METADATA_KEY, a as FieldMetadata, e as extractFieldMetadata } from '../../fields-UcOPu1OQ.js';
+import 'zod';
 
 /**
- * Collection name pluralization utilities
+ * Collection ID generation utilities for PocketBase migrations
  */
 /**
- * Pluralizes a singular noun to its plural form
- * Handles special cases and common English pluralization rules
+ * Generates a unique collection ID in PocketBase format
+ * Format: pb_ followed by 15 alphanumeric lowercase characters
  *
- * @param singular - The singular form of the noun
- * @returns The plural form of the noun
- */
-declare function pluralize(singular: string): string;
-/**
- * Converts a singular entity name to a collection name
- * This is an alias for pluralize for better semantic clarity
- *
- * @param entityName - The singular entity name (e.g., "User", "Project")
- * @returns The collection name (e.g., "Users", "Projects")
- */
-declare function toCollectionName(entityName: string): string;
-/**
- * Attempts to singularize a plural noun (reverse of pluralize)
- * Note: This is a best-effort implementation and may not handle all edge cases
- *
- * @param plural - The plural form of the noun
- * @returns The singular form of the noun
- */
-declare function singularize(plural: string): string;
-
-/**
- * Relation field detection utilities
- */
-
-/**
- * Detects if a field is a single relation based on naming convention
- * Single relation: field name matches a collection name (e.g., "User" -> "Users" collection)
- */
-declare function isSingleRelationField(fieldName: string, zodType: z.ZodTypeAny): boolean;
-/**
- * Detects if a field is a multiple relation based on naming convention
- * Multiple relation: field name is an array of strings ending with entity name
- * (e.g., "SubscriberUsers" -> "Users" collection)
- */
-declare function isMultipleRelationField(fieldName: string, zodType: z.ZodTypeAny): boolean;
-/**
- * Resolves the target collection name from a relation field name
- * Examples:
- * - "User" -> "Users"
- * - "SubscriberUsers" -> "Users"
- * - "Author" -> "Authors"
- * - "Category" -> "Categories"
- */
-declare function resolveTargetCollection(fieldName: string): string;
-/**
- * Detects if a field is any type of relation (single or multiple)
- */
-declare function isRelationField(fieldName: string, zodType: z.ZodTypeAny): boolean;
-/**
- * Gets the maximum number of relations allowed for a relation field
- * Returns 1 for single relations, or the max constraint for multiple relations
- */
-declare function getMaxSelect(fieldName: string, zodType: z.ZodTypeAny): number;
-/**
- * Gets the minimum number of relations required for a relation field
- * Returns 0 as default for all relation fields (single or multiple)
- * PocketBase always expects minSelect to be defined for relation fields
- */
-declare function getMinSelect(fieldName: string, zodType: z.ZodTypeAny): number;
-
-/**
- * Zod to PocketBase type mapping utilities
- *
- * This module provides comprehensive mapping between Zod schema types
- * and PocketBase field types, including support for all PocketBase field types:
- * - text, email, url, editor
- * - number, bool
- * - date, autodate
- * - select (single/multiple)
- * - relation (single/multiple)
- * - file (single/multiple)
- * - json
- * - geoPoint
- */
-
-/**
- * All supported PocketBase field types
- */
-declare const POCKETBASE_FIELD_TYPES: readonly PocketBaseFieldType[];
-/**
- * Field type metadata for documentation and validation
- */
-interface FieldTypeInfo {
-    type: PocketBaseFieldType;
-    description: string;
-    zodTypes: string[];
-    supportsMultiple: boolean;
-}
-/**
- * Metadata about each PocketBase field type
- */
-declare const FIELD_TYPE_INFO: Record<PocketBaseFieldType, FieldTypeInfo>;
-/**
- * Maps Zod string types to PocketBase field types
- */
-declare function mapZodStringType(zodType: z.ZodString): PocketBaseFieldType;
-/**
- * Maps Zod number types to PocketBase number type
- */
-declare function mapZodNumberType(_zodType: z.ZodNumber): PocketBaseFieldType;
-/**
- * Maps Zod boolean types to PocketBase bool type
- */
-declare function mapZodBooleanType(_zodType: z.ZodBoolean): PocketBaseFieldType;
-/**
- * Maps Zod enum types to PocketBase select type
- */
-declare function mapZodEnumType(_zodType: z.ZodEnum<any>): PocketBaseFieldType;
-/**
- * Maps Zod array types to appropriate PocketBase types
- * Arrays of strings could be relations or file fields depending on context
- */
-declare function mapZodArrayType(zodType: z.ZodArray<any>, _fieldName: string): PocketBaseFieldType;
-/**
- * Maps Zod date types to PocketBase date type
- */
-declare function mapZodDateType(_zodType: z.ZodDate): PocketBaseFieldType;
-/**
- * Maps Zod record/object types to PocketBase JSON type
- */
-declare function mapZodRecordType(_zodType: z.ZodRecord | z.ZodObject<any>): PocketBaseFieldType;
-/**
- * Main type mapping function that determines PocketBase field type from Zod type
- */
-declare function mapZodTypeToPocketBase(zodType: z.ZodTypeAny, fieldName: string): PocketBaseFieldType;
-/**
- * Extracts field options from Zod type (min, max, pattern, etc.)
- */
-declare function extractFieldOptions(zodType: z.ZodTypeAny): Record<string, any>;
-/**
- * Determines if a Zod field is required (not optional)
- */
-declare function isFieldRequired(zodType: z.ZodTypeAny): boolean;
-/**
- * Unwraps a Zod type to get the inner type
- * Handles optional, nullable, and default wrappers
- */
-declare function unwrapZodType(zodType: z.ZodTypeAny): z.ZodTypeAny;
-/**
- * Gets the default value from a Zod type if it has one
- */
-declare function getDefaultValue(zodType: z.ZodTypeAny): any;
-/**
- * Checks if a Zod type is an array type
- */
-declare function isArrayType(zodType: z.ZodTypeAny): boolean;
-/**
- * Gets the element type of an array Zod type
- */
-declare function getArrayElementType(zodType: z.ZodTypeAny): z.ZodTypeAny | null;
-/**
- * Checks if a Zod type represents a geo point (object with lon/lat)
- */
-declare function isGeoPointType(zodType: z.ZodTypeAny): boolean;
-/**
- * Complete field options extracted from a Zod type
- */
-interface ExtractedFieldOptions {
-    min?: number;
-    max?: number;
-    pattern?: string;
-    values?: string[];
-    minSelect?: number;
-    maxSelect?: number;
-    mimeTypes?: string[];
-    maxSize?: number;
-    thumbs?: string[];
+ * @returns A unique collection ID string (e.g., "pb_a1b2c3d4e5f6g7h")
+ */
+declare function generateCollectionId(): string;
+/**
+ * Registry to track generated collection IDs and ensure uniqueness within a migration batch
+ */
+declare class CollectionIdRegistry {
+    private ids;
+    constructor();
+    /**
+     * Generates a unique collection ID for a given collection name
+     * Special case: Returns constant "_pb_users_auth_" for users collection
+     * Retries up to 10 times if collision occurs (extremely rare)
+     *
+     * @param collectionName - The name of the collection
+     * @returns A unique collection ID
+     * @throws Error if unable to generate unique ID after max attempts
+     */
+    generate(collectionName?: string): string;
+    /**
+     * Checks if an ID has already been registered
+     *
+     * @param id - The collection ID to check
+     * @returns True if the ID exists in the registry
+     */
+    has(id: string): boolean;
+    /**
+     * Registers a collection ID in the registry
+     *
+     * @param id - The collection ID to register
+     */
+    register(id: string): void;
 }
-/**
- * Extracts comprehensive field options from Zod type
- * Includes all constraints that can be mapped to PocketBase field options
- */
-declare function extractComprehensiveFieldOptions(zodType: z.ZodTypeAny): ExtractedFieldOptions;
-/**
- * Determines if a field should be treated as an editor field
- * based on field name conventions
- */
-declare function isEditorField(fieldName: string): boolean;
-/**
- * Determines if a field should be treated as a file field
- * based on field name conventions
- */
-declare function isFileFieldByName(fieldName: string): boolean;
-/**
- * Gets the PocketBase field type with additional context
- */
-interface FieldTypeResult {
-    type: PocketBaseFieldType;
-    isMultiple: boolean;
-    options: ExtractedFieldOptions;
-}
-/**
- * Comprehensive type mapping that returns full field information
- */
-declare function getFieldTypeInfo(zodType: z.ZodTypeAny, fieldName: string): FieldTypeResult;
 
-export { type ExtractedFieldOptions, FIELD_TYPE_INFO, type FieldTypeInfo, type FieldTypeResult, POCKETBASE_FIELD_TYPES, extractComprehensiveFieldOptions, extractFieldOptions, getArrayElementType, getDefaultValue, getFieldTypeInfo, getMaxSelect, getMinSelect, isArrayType, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isRelationField, isSingleRelationField, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, pluralize, resolveTargetCollection, singularize, toCollectionName, unwrapZodType };
+export { CollectionIdRegistry, generateCollectionId };

package/dist/migration/utils/index.js

@@ -1,5 +1,67 @@
+import { randomBytes } from 'crypto';
 import { z } from 'zod';
 
+// src/migration/utils/collection-id-generator.ts
+function generateCollectionId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const idLength = 15;
+  const bytes = randomBytes(idLength);
+  let id = "pb_";
+  for (let i = 0; i < idLength; i++) {
+    const index = bytes[i] % chars.length;
+    id += chars[index];
+  }
+  return id;
+}
+var CollectionIdRegistry = class {
+  ids;
+  constructor() {
+    this.ids = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Generates a unique collection ID for a given collection name
+   * Special case: Returns constant "_pb_users_auth_" for users collection
+   * Retries up to 10 times if collision occurs (extremely rare)
+   *
+   * @param collectionName - The name of the collection
+   * @returns A unique collection ID
+   * @throws Error if unable to generate unique ID after max attempts
+   */
+  generate(collectionName) {
+    if (collectionName && collectionName.toLowerCase() === "users") {
+      const usersId = "_pb_users_auth_";
+      this.register(usersId);
+      return usersId;
+    }
+    const maxAttempts = 10;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const id = generateCollectionId();
+      if (!this.has(id)) {
+        this.register(id);
+        return id;
+      }
+    }
+    throw new Error("Failed to generate unique collection ID after maximum attempts");
+  }
+  /**
+   * Checks if an ID has already been registered
+   *
+   * @param id - The collection ID to check
+   * @returns True if the ID exists in the registry
+   */
+  has(id) {
+    return this.ids.has(id);
+  }
+  /**
+   * Registers a collection ID in the registry
+   *
+   * @param id - The collection ID to register
+   */
+  register(id) {
+    this.ids.add(id);
+  }
+};
+
 // src/migration/utils/pluralize.ts
 var SPECIAL_CASES = {
   // Common irregular plurals
@@ -652,6 +714,6 @@ function getFieldTypeInfo(zodType, fieldName) {
   };
 }
 
-export { FIELD_METADATA_KEY, FIELD_TYPE_INFO, POCKETBASE_FIELD_TYPES, extractComprehensiveFieldOptions, extractFieldMetadata, extractFieldOptions, getArrayElementType, getDefaultValue, getFieldTypeInfo, getMaxSelect, getMinSelect, isArrayType, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isRelationField, isSingleRelationField, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, pluralize, resolveTargetCollection, singularize, toCollectionName, unwrapZodType };
+export { CollectionIdRegistry, FIELD_METADATA_KEY, FIELD_TYPE_INFO, POCKETBASE_FIELD_TYPES, extractComprehensiveFieldOptions, extractFieldMetadata, extractFieldOptions, generateCollectionId, getArrayElementType, getDefaultValue, getFieldTypeInfo, getMaxSelect, getMinSelect, isArrayType, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isRelationField, isSingleRelationField, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, pluralize, resolveTargetCollection, singularize, toCollectionName, unwrapZodType };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map