pocketbase-zod-schema 0.2.3 → 0.2.5

package/dist/index.js

@@ -15,6 +15,333 @@ var StatusEnum = z.enum([
   "fail"
   // Failed project at any stage
 ]);
+var BaseMutator = class {
+  pb;
+  // Define a default property that subclasses will override
+  options = {
+    expand: [],
+    filter: [],
+    sort: []
+  };
+  constructor(pb, options) {
+    this.pb = pb;
+    this.initializeOptions();
+    if (options) {
+      this.overrideOptions(options);
+    }
+  }
+  initializeOptions() {
+    this.options = this.setDefaults();
+  }
+  /**
+   * Initialize options with class-specific defaults
+   * Subclasses should override this instead of directly setting options
+   */
+  setDefaults() {
+    return {
+      expand: [],
+      filter: [],
+      sort: []
+    };
+  }
+  /**
+   * Merge provided options with current options
+   */
+  overrideOptions(newOptions) {
+    if (newOptions.expand !== void 0) {
+      this.options.expand = newOptions.expand;
+    }
+    if (newOptions.filter !== void 0) {
+      this.options.filter = newOptions.filter;
+    }
+    if (newOptions.sort !== void 0) {
+      this.options.sort = newOptions.sort;
+    }
+  }
+  toSnakeCase(str) {
+    return str.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  }
+  /**
+   * Create a new entity
+   */
+  async create(input) {
+    try {
+      const data = await this.validateInput(input);
+      const record = await this.entityCreate(data);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.errorWrapper(error);
+    }
+  }
+  /**
+   * Update an existing entity
+   */
+  async update(id, input) {
+    try {
+      const record = await this.entityUpdate(id, input);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.errorWrapper(error);
+    }
+  }
+  /**
+   * Create or update entity (upsert)
+   */
+  async upsert(input) {
+    if (input?.id) {
+      return await this.update(input.id, input);
+    }
+    return await this.create(input);
+  }
+  /**
+   * Get entity by ID
+   */
+  async getById(id, expand) {
+    try {
+      const record = await this.entityGetById(id, expand);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.handleError(error, { allowNotFound: true });
+    }
+  }
+  /**
+   * Get first entity by filter
+   */
+  async getFirstByFilter(filter, expand, sort) {
+    try {
+      const record = await this.entityGetFirstByFilter(filter, expand, sort);
+      return await this.processRecord(record);
+    } catch (error) {
+      return this.handleError(error, { allowNotFound: true });
+    }
+  }
+  /**
+   * Get list of entities
+   */
+  async getList(page = 1, perPage = 100, filter, sort, expand) {
+    try {
+      const result = await this.entityGetList(page, perPage, filter, sort, expand);
+      return await this.processListResult(result);
+    } catch (error) {
+      return this.errorWrapper(error);
+    }
+  }
+  /**
+   * Delete entity by ID
+   */
+  async delete(id) {
+    try {
+      return await this.entityDelete(id);
+    } catch (error) {
+      return this.handleError(error, { returnValue: false });
+    }
+  }
+  /**
+   * Process a single record before returning it
+   * Can be overridden to handle special cases like mapped entities
+   */
+  async processRecord(record) {
+    return record;
+  }
+  /**
+   * Process a list result before returning it
+   * Can be overridden to handle special cases like mapped entities
+   */
+  async processListResult(result) {
+    const processedItems = await Promise.all(result.items.map((item) => this.processRecord(item)));
+    return {
+      ...result,
+      items: processedItems
+    };
+  }
+  /**
+   * Prepare expand parameter
+   * Combines default expands with provided expands
+   */
+  prepareExpand(expand) {
+    if (!this.options.expand.length && !expand) {
+      return void 0;
+    }
+    let expandArray = [...this.options.expand];
+    if (expand) {
+      if (typeof expand === "string") {
+        expandArray = expandArray.concat(expand.split(",").map((e) => e.trim()));
+      } else {
+        expandArray = expandArray.concat(expand);
+      }
+    }
+    const uniqueExpands = [...new Set(expandArray)].filter((e) => e !== "" && e !== void 0);
+    if (!uniqueExpands.length) {
+      return void 0;
+    }
+    return uniqueExpands.join(",");
+  }
+  /**
+   * Prepare filter parameter
+   * Combines default filters with provided filters
+   */
+  prepareFilter(filter) {
+    if (!this.options.filter.length && !filter) {
+      return void 0;
+    }
+    let filterArray = [...this.options.filter];
+    if (filter) {
+      if (typeof filter === "string") {
+        if (filter) filterArray.push(filter);
+      } else {
+        filterArray = filterArray.concat(filter);
+      }
+    }
+    const validFilters = filterArray.filter((f) => f !== "" && f !== void 0);
+    if (!validFilters.length) {
+      return void 0;
+    }
+    return validFilters.join("&&");
+  }
+  /**
+   * Prepare sort parameter
+   * Uses provided sort or falls back to default sort
+   */
+  prepareSort(sort) {
+    if (sort && sort !== "") {
+      return sort;
+    }
+    if (this.options.sort.length) {
+      const validSorts = this.options.sort.filter((s) => s !== "" && s !== void 0);
+      if (validSorts.length) {
+        return validSorts.join(",");
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Perform the actual create operation
+   */
+  async entityCreate(data) {
+    return await this.getCollection().create(data);
+  }
+  /**
+   * Perform the actual update operation
+   */
+  async entityUpdate(id, data) {
+    return await this.getCollection().update(id, data);
+  }
+  /**
+   * Perform the actual getById operation
+   */
+  async entityGetById(id, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return await this.getCollection().getOne(id, options);
+  }
+  /**
+   * Perform the actual getFirstByFilter operation
+   */
+  async entityGetFirstByFilter(filter, expand, sort) {
+    const finalFilter = this.prepareFilter(filter);
+    const finalExpand = this.prepareExpand(expand);
+    const finalSort = this.prepareSort(sort);
+    const options = {};
+    if (finalExpand) options.expand = finalExpand;
+    if (finalSort) options.sort = finalSort;
+    return await this.getCollection().getFirstListItem(finalFilter || "", options);
+  }
+  /**
+   * Perform the actual getList operation
+   * Returns a list result with items of type T
+   */
+  async entityGetList(page, perPage, filter, sort, expand) {
+    const finalFilter = this.prepareFilter(filter);
+    const finalExpand = this.prepareExpand(expand);
+    const finalSort = this.prepareSort(sort);
+    const options = {};
+    if (finalFilter) options.filter = finalFilter;
+    if (finalExpand) options.expand = finalExpand;
+    if (finalSort) options.sort = finalSort;
+    return await this.getCollection().getList(page, perPage, options);
+  }
+  /**
+   * Perform the actual delete operation
+   */
+  async entityDelete(id) {
+    await this.getCollection().delete(id);
+    return true;
+  }
+  /**
+   * Error handler for common errors
+   * @param error The error to handle
+   * @param options Handler options
+   * @returns The value to return if the error is handled, or throws if not handled
+   */
+  handleError(error, options = { logError: true }) {
+    const { allowNotFound = false, returnValue, logError: logError2 = true } = options;
+    if (logError2) {
+      console.error(`Error in ${this.constructor.name}:`, error);
+    }
+    if (allowNotFound && this.isNotFoundError(error)) {
+      return null;
+    }
+    if (returnValue !== void 0) {
+      return returnValue;
+    }
+    throw error;
+  }
+  /**
+   * Check if an error is a "not found" error
+   */
+  isNotFoundError(error) {
+    return error instanceof Error && (error.message.includes("404") || error.message.toLowerCase().includes("not found"));
+  }
+  /**
+   * Standard error handling wrapper (legacy method, consider using handleError instead)
+   */
+  errorWrapper(error) {
+    console.error(`Error in ${this.constructor.name}:`, error);
+    throw error;
+  }
+  /**
+   * Subscribe to changes on a specific record
+   * @param id The ID of the record to subscribe to
+   * @param callback Function to call when changes occur
+   * @param expand Optional expand parameters
+   * @returns Promise that resolves to an unsubscribe function
+   */
+  async subscribeToRecord(id, callback, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return this.getCollection().subscribe(id, callback, options);
+  }
+  /**
+   * Subscribe to changes on the entire collection
+   * @param callback Function to call when changes occur
+   * @param expand Optional expand parameters
+   * @returns Promise that resolves to an unsubscribe function
+   */
+  async subscribeToCollection(callback, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return this.getCollection().subscribe("*", callback, options);
+  }
+  /**
+   * Unsubscribe from a specific record's changes
+   * @param id The ID of the record to unsubscribe from
+   */
+  unsubscribeFromRecord(id) {
+    this.getCollection().unsubscribe(id);
+  }
+  /**
+   * Unsubscribe from collection-wide changes
+   */
+  unsubscribeFromCollection() {
+    this.getCollection().unsubscribe("*");
+  }
+  /**
+   * Unsubscribe from all subscriptions in this collection
+   */
+  unsubscribeAll() {
+    this.getCollection().unsubscribe();
+  }
+};
 var baseSchema = {
   id: z.string().describe("unique id"),
   collectionId: z.string().describe("collection id"),
@@ -37,762 +364,544 @@ var inputImageFileSchema = {
   imageFiles: z.array(z.instanceof(File))
 };
 var omitImageFilesSchema = {
-  imageFiles: true
-};
-function textField(options) {
-  let schema = z.string();
-  if (options?.min !== void 0) schema = schema.min(options.min);
-  if (options?.max !== void 0) schema = schema.max(options.max);
-  if (options?.pattern !== void 0) schema = schema.regex(options.pattern);
-  return schema;
-}
-function emailField() {
-  return z.string().email();
-}
-function urlField() {
-  return z.string().url();
-}
-function numberField(options) {
-  let schema = z.number();
-  if (options?.min !== void 0) schema = schema.min(options.min);
-  if (options?.max !== void 0) schema = schema.max(options.max);
-  return schema;
-}
-function boolField() {
-  return z.boolean();
-}
-function dateField() {
-  return z.date();
-}
-function selectField(values) {
-  return z.enum(values);
-}
-function jsonField(schema) {
-  return schema ?? z.record(z.any());
-}
-function fileField() {
-  return z.instanceof(File);
-}
-function filesField(options) {
-  let schema = z.array(z.instanceof(File));
-  if (options?.min !== void 0) schema = schema.min(options.min);
-  if (options?.max !== void 0) schema = schema.max(options.max);
-  return schema;
-}
-var RELATION_METADATA_KEY = "__pocketbase_relation__";
-function RelationField(config) {
-  const metadata = {
-    [RELATION_METADATA_KEY]: {
-      type: "single",
-      collection: config.collection,
-      cascadeDelete: config.cascadeDelete ?? false,
-      maxSelect: 1,
-      minSelect: 0
-    }
-  };
-  return z.string().describe(JSON.stringify(metadata));
-}
-function RelationsField(config) {
-  const metadata = {
-    [RELATION_METADATA_KEY]: {
-      type: "multiple",
-      collection: config.collection,
-      cascadeDelete: config.cascadeDelete ?? false,
-      maxSelect: config.maxSelect ?? 999,
-      minSelect: config.minSelect ?? 0
-    }
-  };
-  let schema = z.array(z.string());
-  if (config.minSelect !== void 0) {
-    schema = schema.min(config.minSelect);
-  }
-  if (config.maxSelect !== void 0) {
-    schema = schema.max(config.maxSelect);
-  }
-  return schema.describe(JSON.stringify(metadata));
-}
-function extractRelationMetadata(description) {
-  if (!description) return null;
-  try {
-    const parsed = JSON.parse(description);
-    if (parsed[RELATION_METADATA_KEY]) {
-      return parsed[RELATION_METADATA_KEY];
-    }
-  } catch {
-  }
-  return null;
-}
-function editorField() {
-  return z.string();
-}
-function geoPointField() {
-  return z.object({
-    lon: z.number(),
-    lat: z.number()
-  });
-}
-function withPermissions(schema, config) {
-  const metadata = {
-    permissions: config
-  };
-  return schema.describe(JSON.stringify(metadata));
-}
-function withIndexes(schema, indexes) {
-  let existingMetadata = {};
-  if (schema.description) {
-    try {
-      existingMetadata = JSON.parse(schema.description);
-    } catch {
-    }
-  }
-  const metadata = {
-    ...existingMetadata,
-    indexes
-  };
-  return schema.describe(JSON.stringify(metadata));
-}
-function defineCollection(config) {
-  const { collectionName, schema, permissions, indexes, type, ...futureOptions } = config;
-  const metadata = {
-    collectionName
-  };
-  if (type) {
-    metadata.type = type;
-  }
-  if (permissions) {
-    metadata.permissions = permissions;
-  }
-  if (indexes) {
-    metadata.indexes = indexes;
-  }
-  if (Object.keys(futureOptions).length > 0) {
-    Object.assign(metadata, futureOptions);
-  }
-  return schema.describe(JSON.stringify(metadata));
-}
-
-// src/utils/permission-templates.ts
-var PermissionTemplates = {
-  /**
-   * Public access - anyone can perform all operations
-   */
-  public: () => ({
-    listRule: "",
-    viewRule: "",
-    createRule: "",
-    updateRule: "",
-    deleteRule: ""
-  }),
-  /**
-   * Authenticated users only - requires valid authentication for all operations
-   */
-  authenticated: () => ({
-    listRule: '@request.auth.id != ""',
-    viewRule: '@request.auth.id != ""',
-    createRule: '@request.auth.id != ""',
-    updateRule: '@request.auth.id != ""',
-    deleteRule: '@request.auth.id != ""'
-  }),
-  /**
-   * Owner-only access - users can only manage their own records
-   * @param ownerField - Name of the relation field pointing to user (default: 'User')
-   */
-  ownerOnly: (ownerField = "User") => ({
-    listRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
-    viewRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
-    createRule: '@request.auth.id != ""',
-    updateRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
-    deleteRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`
-  }),
-  /**
-   * Admin/superuser only access
-   * Assumes a 'role' field exists with 'admin' value
-   * @param roleField - Name of the role field (default: 'role')
-   */
-  adminOnly: (roleField = "role") => ({
-    listRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
-    viewRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
-    createRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
-    updateRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
-    deleteRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`
-  }),
-  /**
-   * Public read, authenticated write
-   * Anyone can list/view, but only authenticated users can create/update/delete
-   */
-  readPublic: () => ({
-    listRule: "",
-    viewRule: "",
-    createRule: '@request.auth.id != ""',
-    updateRule: '@request.auth.id != ""',
-    deleteRule: '@request.auth.id != ""'
-  }),
-  /**
-   * Locked access - only superusers can perform operations
-   * All rules are set to null (locked)
-   */
-  locked: () => ({
-    listRule: null,
-    viewRule: null,
-    createRule: null,
-    updateRule: null,
-    deleteRule: null
-  }),
-  /**
-   * Read-only authenticated - authenticated users can read, no write access
-   */
-  readOnlyAuthenticated: () => ({
-    listRule: '@request.auth.id != ""',
-    viewRule: '@request.auth.id != ""',
-    createRule: null,
-    updateRule: null,
-    deleteRule: null
-  })
-};
-function resolveTemplate(config) {
-  let baseRules;
-  switch (config.template) {
-    case "public":
-      baseRules = PermissionTemplates.public();
-      break;
-    case "authenticated":
-      baseRules = PermissionTemplates.authenticated();
-      break;
-    case "owner-only":
-      baseRules = PermissionTemplates.ownerOnly(config.ownerField);
-      break;
-    case "admin-only":
-      baseRules = PermissionTemplates.adminOnly(config.roleField);
-      break;
-    case "read-public":
-      baseRules = PermissionTemplates.readPublic();
-      break;
-    case "custom":
-      baseRules = {};
-      break;
-    default: {
-      const _exhaustive = config.template;
-      throw new Error(`Unknown template type: ${_exhaustive}`);
-    }
-  }
-  return {
-    ...baseRules,
-    ...config.customRules
-  };
+  imageFiles: true
+};
+function textField(options) {
+  let schema = z.string();
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  if (options?.pattern !== void 0) schema = schema.regex(options.pattern);
+  return schema;
 }
-function isTemplateConfig(config) {
-  return "template" in config;
+function emailField() {
+  return z.string().email();
 }
-function isPermissionSchema(config) {
-  return "listRule" in config || "viewRule" in config || "createRule" in config || "updateRule" in config || "deleteRule" in config || "manageRule" in config;
+function urlField() {
+  return z.string().url();
 }
-function validatePermissionConfig(config, isAuthCollection2 = false) {
-  const result = {
-    valid: true,
-    errors: [],
-    warnings: []
-  };
-  let permissions;
-  if (isTemplateConfig(config)) {
-    if (config.template === "owner-only" && !config.ownerField) {
-      result.warnings.push("owner-only template without ownerField specified - using default 'User'");
-    }
-    if (config.template === "admin-only" && !config.roleField) {
-      result.warnings.push("admin-only template without roleField specified - using default 'role'");
-    }
-    permissions = resolveTemplate(config);
-  } else {
-    permissions = config;
-  }
-  if (permissions.manageRule !== void 0 && !isAuthCollection2) {
-    result.errors.push("manageRule is only valid for auth collections");
-    result.valid = false;
-  }
-  const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule"];
-  if (isAuthCollection2) {
-    ruleTypes.push("manageRule");
-  }
-  for (const ruleType of ruleTypes) {
-    const rule = permissions[ruleType];
-    if (rule !== void 0 && rule !== null && rule !== "") {
-      const ruleValidation = validateRuleExpression(rule);
-      if (!ruleValidation.valid) {
-        result.errors.push(`${ruleType}: ${ruleValidation.errors.join(", ")}`);
-        result.valid = false;
-      }
-      result.warnings.push(...ruleValidation.warnings.map((w) => `${ruleType}: ${w}`));
-    }
-  }
-  return result;
+function numberField(options) {
+  let schema = z.number();
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  return schema;
 }
-function validateRuleExpression(expression) {
-  const result = {
-    valid: true,
-    errors: [],
-    warnings: []
+function boolField() {
+  return z.boolean();
+}
+function dateField() {
+  return z.date();
+}
+function selectField(values) {
+  return z.enum(values);
+}
+function jsonField(schema) {
+  return schema ?? z.record(z.any());
+}
+function fileField() {
+  return z.instanceof(File);
+}
+function filesField(options) {
+  let schema = z.array(z.instanceof(File));
+  if (options?.min !== void 0) schema = schema.min(options.min);
+  if (options?.max !== void 0) schema = schema.max(options.max);
+  return schema;
+}
+var RELATION_METADATA_KEY = "__pocketbase_relation__";
+function RelationField(config) {
+  const metadata = {
+    [RELATION_METADATA_KEY]: {
+      type: "single",
+      collection: config.collection,
+      cascadeDelete: config.cascadeDelete ?? false,
+      maxSelect: 1,
+      minSelect: 0
+    }
   };
-  if (expression === null || expression === "") {
-    return result;
-  }
-  let parenCount = 0;
-  for (const char of expression) {
-    if (char === "(") parenCount++;
-    if (char === ")") parenCount--;
-    if (parenCount < 0) {
-      result.errors.push("Unbalanced parentheses");
-      result.valid = false;
-      return result;
+  return z.string().describe(JSON.stringify(metadata));
+}
+function RelationsField(config) {
+  const metadata = {
+    [RELATION_METADATA_KEY]: {
+      type: "multiple",
+      collection: config.collection,
+      cascadeDelete: config.cascadeDelete ?? false,
+      maxSelect: config.maxSelect ?? 999,
+      minSelect: config.minSelect ?? 0
     }
+  };
+  let schema = z.array(z.string());
+  if (config.minSelect !== void 0) {
+    schema = schema.min(config.minSelect);
   }
-  if (parenCount !== 0) {
-    result.errors.push("Unbalanced parentheses");
-    result.valid = false;
-  }
-  if (expression.includes("==")) {
-    result.warnings.push("Use '=' instead of '==' for equality comparison");
+  if (config.maxSelect !== void 0) {
+    schema = schema.max(config.maxSelect);
   }
-  const requestRefs = expression.match(/@request\.[a-zA-Z_][a-zA-Z0-9_.]*/g) || [];
-  for (const ref of requestRefs) {
-    const isValid = ref.startsWith("@request.auth.") || ref === "@request.method" || ref === "@request.context" || ref.startsWith("@request.body.") || ref.startsWith("@request.query.") || ref.startsWith("@request.headers.");
-    if (!isValid) {
-      result.errors.push(`Invalid @request reference: '${ref}'`);
-      result.valid = false;
+  return schema.describe(JSON.stringify(metadata));
+}
+function extractRelationMetadata(description) {
+  if (!description) return null;
+  try {
+    const parsed = JSON.parse(description);
+    if (parsed[RELATION_METADATA_KEY]) {
+      return parsed[RELATION_METADATA_KEY];
     }
+  } catch {
   }
-  return result;
+  return null;
 }
-function createPermissions(permissions) {
-  return {
-    listRule: permissions.listRule ?? null,
-    viewRule: permissions.viewRule ?? null,
-    createRule: permissions.createRule ?? null,
-    updateRule: permissions.updateRule ?? null,
-    deleteRule: permissions.deleteRule ?? null,
-    manageRule: permissions.manageRule ?? null
-  };
+function editorField() {
+  return z.string();
 }
-function mergePermissions(...schemas) {
-  const merged = {
-    listRule: null,
-    viewRule: null,
-    createRule: null,
-    updateRule: null,
-    deleteRule: null,
-    manageRule: null
+function geoPointField() {
+  return z.object({
+    lon: z.number(),
+    lat: z.number()
+  });
+}
+function withPermissions(schema, config) {
+  const metadata = {
+    permissions: config
   };
-  for (const schema of schemas) {
-    if (schema.listRule !== void 0) merged.listRule = schema.listRule;
-    if (schema.viewRule !== void 0) merged.viewRule = schema.viewRule;
-    if (schema.createRule !== void 0) merged.createRule = schema.createRule;
-    if (schema.updateRule !== void 0) merged.updateRule = schema.updateRule;
-    if (schema.deleteRule !== void 0) merged.deleteRule = schema.deleteRule;
-    if (schema.manageRule !== void 0) merged.manageRule = schema.manageRule;
-  }
-  return merged;
+  return schema.describe(JSON.stringify(metadata));
 }
-var ProjectInputSchema = z.object({
-  // Required fields
-  title: z.string(),
-  content: z.string(),
-  status: StatusEnum,
-  summary: z.string().optional(),
-  OwnerUser: RelationField({ collection: "Users" }),
-  SubscriberUsers: RelationsField({ collection: "Users" })
-}).extend(inputImageFileSchema);
-var ProjectSchema = ProjectInputSchema.omit(omitImageFilesSchema).extend(baseImageFileSchema);
-var ProjectCollection = defineCollection({
-  collectionName: "Projects",
-  schema: ProjectSchema,
-  permissions: {
-    template: "owner-only",
-    ownerField: "OwnerUser",
-    customRules: {
-      listRule: '@request.auth.id != ""',
-      viewRule: '@request.auth.id != "" && (OwnerUser = @request.auth.id || SubscriberUsers ?= @request.auth.id)'
+function withIndexes(schema, indexes) {
+  let existingMetadata = {};
+  if (schema.description) {
+    try {
+      existingMetadata = JSON.parse(schema.description);
+    } catch {
     }
   }
-});
-var UserInputSchema = z.object({
-  name: z.string().optional(),
-  email: z.string().email(),
-  password: z.string().min(8, "Password must be at least 8 characters"),
-  passwordConfirm: z.string(),
-  avatar: z.instanceof(File).optional()
-});
-var UserCollectionSchema = z.object({
-  name: z.string().optional(),
-  email: z.string().email(),
-  password: z.string().min(8, "Password must be at least 8 characters"),
-  avatar: z.instanceof(File).optional()
-});
-var UserSchema = UserCollectionSchema.extend(baseSchema);
-var UserCollection = defineCollection({
-  collectionName: "users",
-  type: "auth",
-  schema: UserSchema,
-  permissions: {
-    // Users can list their own profile
-    listRule: "id = @request.auth.id",
-    // Users can view their own profile
-    viewRule: "id = @request.auth.id",
-    // Anyone can create an account (sign up)
-    createRule: "",
-    // Users can only update their own profile
-    updateRule: "id = @request.auth.id",
-    // Users can only delete their own account
-    deleteRule: "id = @request.auth.id"
-    // manageRule is null in PocketBase default (not set)
-  },
-  indexes: [
-    // PocketBase's default indexes for auth collections
-    "CREATE UNIQUE INDEX `idx_tokenKey__pb_users_auth_` ON `users` (`tokenKey`)",
-    "CREATE UNIQUE INDEX `idx_email__pb_users_auth_` ON `users` (`email`) WHERE `email` != ''"
-  ]
-});
-var BaseMutator = class {
-  pb;
-  // Define a default property that subclasses will override
-  options = {
-    expand: [],
-    filter: [],
-    sort: []
+  const metadata = {
+    ...existingMetadata,
+    indexes
   };
-  constructor(pb, options) {
-    this.pb = pb;
-    this.initializeOptions();
-    if (options) {
-      this.overrideOptions(options);
-    }
+  return schema.describe(JSON.stringify(metadata));
+}
+function defineCollection(config) {
+  const { collectionName, schema, permissions, indexes, type, ...futureOptions } = config;
+  const metadata = {
+    collectionName
+  };
+  if (type) {
+    metadata.type = type;
   }
-  initializeOptions() {
-    this.options = this.setDefaults();
+  if (permissions) {
+    metadata.permissions = permissions;
   }
-  /**
-   * Initialize options with class-specific defaults
-   * Subclasses should override this instead of directly setting options
-   */
-  setDefaults() {
-    return {
-      expand: [],
-      filter: [],
-      sort: []
-    };
+  if (indexes) {
+    metadata.indexes = indexes;
   }
-  /**
-   * Merge provided options with current options
-   */
-  overrideOptions(newOptions) {
-    if (newOptions.expand !== void 0) {
-      this.options.expand = newOptions.expand;
-    }
-    if (newOptions.filter !== void 0) {
-      this.options.filter = newOptions.filter;
-    }
-    if (newOptions.sort !== void 0) {
-      this.options.sort = newOptions.sort;
+  if (Object.keys(futureOptions).length > 0) {
+    Object.assign(metadata, futureOptions);
+  }
+  return schema.describe(JSON.stringify(metadata));
+}
+var FIELD_METADATA_KEY = "__pocketbase_field__";
+function extractFieldMetadata(description) {
+  if (!description) return null;
+  try {
+    const parsed = JSON.parse(description);
+    if (parsed[FIELD_METADATA_KEY]) {
+      return parsed[FIELD_METADATA_KEY];
     }
+  } catch {
   }
-  toSnakeCase(str) {
-    return str.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
-  }
-  /**
-   * Create a new entity
-   */
-  async create(input) {
-    try {
-      const data = await this.validateInput(input);
-      const record = await this.entityCreate(data);
-      return await this.processRecord(record);
-    } catch (error) {
-      return this.errorWrapper(error);
+  return null;
+}
+function BoolField() {
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "bool"
     }
-  }
-  /**
-   * Update an existing entity
-   */
-  async update(id, input) {
-    try {
-      const record = await this.entityUpdate(id, input);
-      return await this.processRecord(record);
-    } catch (error) {
-      return this.errorWrapper(error);
+  };
+  return z.boolean().describe(JSON.stringify(metadata));
+}
+function NumberField(options) {
+  if (options?.min !== void 0 && options?.max !== void 0) {
+    if (options.min > options.max) {
+      throw new Error("NumberField: min cannot be greater than max");
     }
   }
-  /**
-   * Create or update entity (upsert)
-   */
-  async upsert(input) {
-    if (input?.id) {
-      return await this.update(input.id, input);
-    }
-    return await this.create(input);
+  let schema = z.number();
+  if (options?.min !== void 0) {
+    schema = schema.min(options.min);
   }
-  /**
-   * Get entity by ID
-   */
-  async getById(id, expand) {
-    try {
-      const record = await this.entityGetById(id, expand);
-      return await this.processRecord(record);
-    } catch (error) {
-      return this.handleError(error, { allowNotFound: true });
-    }
+  if (options?.max !== void 0) {
+    schema = schema.max(options.max);
   }
-  /**
-   * Get first entity by filter
-   */
-  async getFirstByFilter(filter, expand, sort) {
-    try {
-      const record = await this.entityGetFirstByFilter(filter, expand, sort);
-      return await this.processRecord(record);
-    } catch (error) {
-      return this.handleError(error, { allowNotFound: true });
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "number",
+      options: options || {}
     }
-  }
-  /**
-   * Get list of entities
-   */
-  async getList(page = 1, perPage = 100, filter, sort, expand) {
-    try {
-      const result = await this.entityGetList(page, perPage, filter, sort, expand);
-      return await this.processListResult(result);
-    } catch (error) {
-      return this.errorWrapper(error);
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+function TextField(options) {
+  if (options?.min !== void 0 && options?.max !== void 0) {
+    if (options.min > options.max) {
+      throw new Error("TextField: min cannot be greater than max");
     }
   }
-  /**
-   * Delete entity by ID
-   */
-  async delete(id) {
-    try {
-      return await this.entityDelete(id);
-    } catch (error) {
-      return this.handleError(error, { returnValue: false });
-    }
+  let schema = z.string();
+  if (options?.min !== void 0) {
+    schema = schema.min(options.min);
   }
-  /**
-   * Process a single record before returning it
-   * Can be overridden to handle special cases like mapped entities
-   */
-  async processRecord(record) {
-    return record;
+  if (options?.max !== void 0) {
+    schema = schema.max(options.max);
   }
-  /**
-   * Process a list result before returning it
-   * Can be overridden to handle special cases like mapped entities
-   */
-  async processListResult(result) {
-    const processedItems = await Promise.all(result.items.map((item) => this.processRecord(item)));
-    return {
-      ...result,
-      items: processedItems
-    };
+  if (options?.pattern !== void 0) {
+    const pattern = options.pattern instanceof RegExp ? options.pattern : new RegExp(options.pattern);
+    schema = schema.regex(pattern);
   }
-  /**
-   * Prepare expand parameter
-   * Combines default expands with provided expands
-   */
-  prepareExpand(expand) {
-    if (!this.options.expand.length && !expand) {
-      return void 0;
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "text",
+      options: options || {}
     }
-    let expandArray = [...this.options.expand];
-    if (expand) {
-      if (typeof expand === "string") {
-        expandArray = expandArray.concat(expand.split(",").map((e) => e.trim()));
-      } else {
-        expandArray = expandArray.concat(expand);
-      }
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+function EmailField() {
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "email"
     }
-    const uniqueExpands = [...new Set(expandArray)].filter((e) => e !== "" && e !== void 0);
-    if (!uniqueExpands.length) {
-      return void 0;
+  };
+  return z.string().email().describe(JSON.stringify(metadata));
+}
+function URLField() {
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "url"
+    }
+  };
+  return z.string().url().describe(JSON.stringify(metadata));
+}
+function EditorField() {
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "editor"
+    }
+  };
+  return z.string().describe(JSON.stringify(metadata));
+}
+function DateField(options) {
+  if (options?.min !== void 0 && options?.max !== void 0) {
+    const minDate = typeof options.min === "string" ? new Date(options.min) : options.min;
+    const maxDate = typeof options.max === "string" ? new Date(options.max) : options.max;
+    if (minDate > maxDate) {
+      throw new Error("DateField: min cannot be greater than max");
     }
-    return uniqueExpands.join(",");
   }
-  /**
-   * Prepare filter parameter
-   * Combines default filters with provided filters
-   */
-  prepareFilter(filter) {
-    if (!this.options.filter.length && !filter) {
-      return void 0;
+  const schema = z.string();
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "date",
+      options: options || {}
     }
-    let filterArray = [...this.options.filter];
-    if (filter) {
-      if (typeof filter === "string") {
-        if (filter) filterArray.push(filter);
-      } else {
-        filterArray = filterArray.concat(filter);
-      }
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+function AutodateField(options) {
+  const schema = z.string();
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "autodate",
+      options: options || {}
     }
-    const validFilters = filterArray.filter((f) => f !== "" && f !== void 0);
-    if (!validFilters.length) {
-      return void 0;
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+function SelectField(values, options) {
+  const enumSchema = z.enum(values);
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "select",
+      options: {
+        values,
+        maxSelect: options?.maxSelect ?? 1
+      }
     }
-    return validFilters.join("&&");
+  };
+  if (options?.maxSelect && options.maxSelect > 1) {
+    return z.array(enumSchema).describe(JSON.stringify(metadata));
   }
-  /**
-   * Prepare sort parameter
-   * Uses provided sort or falls back to default sort
-   */
-  prepareSort(sort) {
-    if (sort && sort !== "") {
-      return sort;
+  return enumSchema.describe(JSON.stringify(metadata));
+}
+function FileField(options) {
+  const schema = z.instanceof(File);
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "file",
+      options: options || {}
     }
-    if (this.options.sort.length) {
-      const validSorts = this.options.sort.filter((s) => s !== "" && s !== void 0);
-      if (validSorts.length) {
-        return validSorts.join(",");
-      }
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+function FilesField(options) {
+  if (options?.minSelect !== void 0 && options?.maxSelect !== void 0) {
+    if (options.minSelect > options.maxSelect) {
+      throw new Error("FilesField: minSelect cannot be greater than maxSelect");
     }
-    return void 0;
   }
-  /**
-   * Perform the actual create operation
-   */
-  async entityCreate(data) {
-    return await this.getCollection().create(data);
+  let schema = z.array(z.instanceof(File));
+  if (options?.minSelect !== void 0) {
+    schema = schema.min(options.minSelect);
+  }
+  if (options?.maxSelect !== void 0) {
+    schema = schema.max(options.maxSelect);
   }
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "file",
+      options: options || {}
+    }
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+function JSONField(schema) {
+  const baseSchema2 = schema ?? z.record(z.string(), z.any());
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "json"
+    }
+  };
+  return baseSchema2.describe(JSON.stringify(metadata));
+}
+function GeoPointField() {
+  const schema = z.object({
+    lon: z.number(),
+    lat: z.number()
+  });
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "geoPoint"
+    }
+  };
+  return schema.describe(JSON.stringify(metadata));
+}
+
+// src/utils/permission-templates.ts
+var PermissionTemplates = {
   /**
-   * Perform the actual update operation
+   * Public access - anyone can perform all operations
    */
-  async entityUpdate(id, data) {
-    return await this.getCollection().update(id, data);
-  }
+  public: () => ({
+    listRule: "",
+    viewRule: "",
+    createRule: "",
+    updateRule: "",
+    deleteRule: ""
+  }),
   /**
-   * Perform the actual getById operation
+   * Authenticated users only - requires valid authentication for all operations
    */
-  async entityGetById(id, expand) {
-    const finalExpand = this.prepareExpand(expand);
-    const options = finalExpand ? { expand: finalExpand } : {};
-    return await this.getCollection().getOne(id, options);
-  }
+  authenticated: () => ({
+    listRule: '@request.auth.id != ""',
+    viewRule: '@request.auth.id != ""',
+    createRule: '@request.auth.id != ""',
+    updateRule: '@request.auth.id != ""',
+    deleteRule: '@request.auth.id != ""'
+  }),
   /**
-   * Perform the actual getFirstByFilter operation
+   * Owner-only access - users can only manage their own records
+   * @param ownerField - Name of the relation field pointing to user (default: 'User')
    */
-  async entityGetFirstByFilter(filter, expand, sort) {
-    const finalFilter = this.prepareFilter(filter);
-    const finalExpand = this.prepareExpand(expand);
-    const finalSort = this.prepareSort(sort);
-    const options = {};
-    if (finalExpand) options.expand = finalExpand;
-    if (finalSort) options.sort = finalSort;
-    return await this.getCollection().getFirstListItem(finalFilter || "", options);
-  }
+  ownerOnly: (ownerField = "User") => ({
+    listRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    viewRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    createRule: '@request.auth.id != ""',
+    updateRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`,
+    deleteRule: `@request.auth.id != "" && ${ownerField} = @request.auth.id`
+  }),
+  /**
+   * Admin/superuser only access
+   * Assumes a 'role' field exists with 'admin' value
+   * @param roleField - Name of the role field (default: 'role')
+   */
+  adminOnly: (roleField = "role") => ({
+    listRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    viewRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    createRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    updateRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`,
+    deleteRule: `@request.auth.id != "" && @request.auth.${roleField} = "admin"`
+  }),
   /**
-   * Perform the actual getList operation
-   * Returns a list result with items of type T
+   * Public read, authenticated write
+   * Anyone can list/view, but only authenticated users can create/update/delete
    */
-  async entityGetList(page, perPage, filter, sort, expand) {
-    const finalFilter = this.prepareFilter(filter);
-    const finalExpand = this.prepareExpand(expand);
-    const finalSort = this.prepareSort(sort);
-    const options = {};
-    if (finalFilter) options.filter = finalFilter;
-    if (finalExpand) options.expand = finalExpand;
-    if (finalSort) options.sort = finalSort;
-    return await this.getCollection().getList(page, perPage, options);
-  }
+  readPublic: () => ({
+    listRule: "",
+    viewRule: "",
+    createRule: '@request.auth.id != ""',
+    updateRule: '@request.auth.id != ""',
+    deleteRule: '@request.auth.id != ""'
+  }),
   /**
-   * Perform the actual delete operation
+   * Locked access - only superusers can perform operations
+   * All rules are set to null (locked)
    */
-  async entityDelete(id) {
-    await this.getCollection().delete(id);
-    return true;
-  }
+  locked: () => ({
+    listRule: null,
+    viewRule: null,
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  }),
   /**
-   * Error handler for common errors
-   * @param error The error to handle
-   * @param options Handler options
-   * @returns The value to return if the error is handled, or throws if not handled
+   * Read-only authenticated - authenticated users can read, no write access
    */
-  handleError(error, options = { logError: true }) {
-    const { allowNotFound = false, returnValue, logError: logError2 = true } = options;
-    if (logError2) {
-      console.error(`Error in ${this.constructor.name}:`, error);
+  readOnlyAuthenticated: () => ({
+    listRule: '@request.auth.id != ""',
+    viewRule: '@request.auth.id != ""',
+    createRule: null,
+    updateRule: null,
+    deleteRule: null
+  })
+};
+function resolveTemplate(config) {
+  let baseRules;
+  switch (config.template) {
+    case "public":
+      baseRules = PermissionTemplates.public();
+      break;
+    case "authenticated":
+      baseRules = PermissionTemplates.authenticated();
+      break;
+    case "owner-only":
+      baseRules = PermissionTemplates.ownerOnly(config.ownerField);
+      break;
+    case "admin-only":
+      baseRules = PermissionTemplates.adminOnly(config.roleField);
+      break;
+    case "read-public":
+      baseRules = PermissionTemplates.readPublic();
+      break;
+    case "custom":
+      baseRules = {};
+      break;
+    default: {
+      const _exhaustive = config.template;
+      throw new Error(`Unknown template type: ${_exhaustive}`);
     }
-    if (allowNotFound && this.isNotFoundError(error)) {
-      return null;
+  }
+  return {
+    ...baseRules,
+    ...config.customRules
+  };
+}
+function isTemplateConfig(config) {
+  return "template" in config;
+}
+function isPermissionSchema(config) {
+  return "listRule" in config || "viewRule" in config || "createRule" in config || "updateRule" in config || "deleteRule" in config || "manageRule" in config;
+}
+function validatePermissionConfig(config, isAuthCollection2 = false) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  let permissions;
+  if (isTemplateConfig(config)) {
+    if (config.template === "owner-only" && !config.ownerField) {
+      result.warnings.push("owner-only template without ownerField specified - using default 'User'");
     }
-    if (returnValue !== void 0) {
-      return returnValue;
+    if (config.template === "admin-only" && !config.roleField) {
+      result.warnings.push("admin-only template without roleField specified - using default 'role'");
     }
-    throw error;
-  }
-  /**
-   * Check if an error is a "not found" error
-   */
-  isNotFoundError(error) {
-    return error instanceof Error && (error.message.includes("404") || error.message.toLowerCase().includes("not found"));
+    permissions = resolveTemplate(config);
+  } else {
+    permissions = config;
   }
-  /**
-   * Standard error handling wrapper (legacy method, consider using handleError instead)
-   */
-  errorWrapper(error) {
-    console.error(`Error in ${this.constructor.name}:`, error);
-    throw error;
+  if (permissions.manageRule !== void 0 && !isAuthCollection2) {
+    result.errors.push("manageRule is only valid for auth collections");
+    result.valid = false;
   }
-  /**
-   * Subscribe to changes on a specific record
-   * @param id The ID of the record to subscribe to
-   * @param callback Function to call when changes occur
-   * @param expand Optional expand parameters
-   * @returns Promise that resolves to an unsubscribe function
-   */
-  async subscribeToRecord(id, callback, expand) {
-    const finalExpand = this.prepareExpand(expand);
-    const options = finalExpand ? { expand: finalExpand } : {};
-    return this.getCollection().subscribe(id, callback, options);
+  const ruleTypes = ["listRule", "viewRule", "createRule", "updateRule", "deleteRule"];
+  if (isAuthCollection2) {
+    ruleTypes.push("manageRule");
   }
-  /**
-   * Subscribe to changes on the entire collection
-   * @param callback Function to call when changes occur
-   * @param expand Optional expand parameters
-   * @returns Promise that resolves to an unsubscribe function
-   */
-  async subscribeToCollection(callback, expand) {
-    const finalExpand = this.prepareExpand(expand);
-    const options = finalExpand ? { expand: finalExpand } : {};
-    return this.getCollection().subscribe("*", callback, options);
+  for (const ruleType of ruleTypes) {
+    const rule = permissions[ruleType];
+    if (rule !== void 0 && rule !== null && rule !== "") {
+      const ruleValidation = validateRuleExpression(rule);
+      if (!ruleValidation.valid) {
+        result.errors.push(`${ruleType}: ${ruleValidation.errors.join(", ")}`);
+        result.valid = false;
+      }
+      result.warnings.push(...ruleValidation.warnings.map((w) => `${ruleType}: ${w}`));
+    }
   }
-  /**
-   * Unsubscribe from a specific record's changes
-   * @param id The ID of the record to unsubscribe from
-   */
-  unsubscribeFromRecord(id) {
-    this.getCollection().unsubscribe(id);
+  return result;
+}
+function validateRuleExpression(expression) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  if (expression === null || expression === "") {
+    return result;
   }
-  /**
-   * Unsubscribe from collection-wide changes
-   */
-  unsubscribeFromCollection() {
-    this.getCollection().unsubscribe("*");
+  let parenCount = 0;
+  for (const char of expression) {
+    if (char === "(") parenCount++;
+    if (char === ")") parenCount--;
+    if (parenCount < 0) {
+      result.errors.push("Unbalanced parentheses");
+      result.valid = false;
+      return result;
+    }
   }
-  /**
-   * Unsubscribe from all subscriptions in this collection
-   */
-  unsubscribeAll() {
-    this.getCollection().unsubscribe();
+  if (parenCount !== 0) {
+    result.errors.push("Unbalanced parentheses");
+    result.valid = false;
   }
-};
-
-// src/mutator/userMutator.ts
-var UserMutator = class extends BaseMutator {
-  setDefaults() {
-    return {
-      expand: [],
-      filter: [],
-      sort: ["-updated"]
-    };
+  if (expression.includes("==")) {
+    result.warnings.push("Use '=' instead of '==' for equality comparison");
   }
-  getCollection() {
-    return this.pb.collection("Users");
+  const requestRefs = expression.match(/@request\.[a-zA-Z_][a-zA-Z0-9_.]*/g) || [];
+  for (const ref of requestRefs) {
+    const isValid = ref.startsWith("@request.auth.") || ref === "@request.method" || ref === "@request.context" || ref.startsWith("@request.body.") || ref.startsWith("@request.query.") || ref.startsWith("@request.headers.");
+    if (!isValid) {
+      result.errors.push(`Invalid @request reference: '${ref}'`);
+      result.valid = false;
+    }
   }
-  async validateInput(input) {
-    return UserInputSchema.parse(input);
+  return result;
+}
+function createPermissions(permissions) {
+  return {
+    listRule: permissions.listRule ?? null,
+    viewRule: permissions.viewRule ?? null,
+    createRule: permissions.createRule ?? null,
+    updateRule: permissions.updateRule ?? null,
+    deleteRule: permissions.deleteRule ?? null,
+    manageRule: permissions.manageRule ?? null
+  };
+}
+function mergePermissions(...schemas) {
+  const merged = {
+    listRule: null,
+    viewRule: null,
+    createRule: null,
+    updateRule: null,
+    deleteRule: null,
+    manageRule: null
+  };
+  for (const schema of schemas) {
+    if (schema.listRule !== void 0) merged.listRule = schema.listRule;
+    if (schema.viewRule !== void 0) merged.viewRule = schema.viewRule;
+    if (schema.createRule !== void 0) merged.createRule = schema.createRule;
+    if (schema.updateRule !== void 0) merged.updateRule = schema.updateRule;
+    if (schema.deleteRule !== void 0) merged.deleteRule = schema.deleteRule;
+    if (schema.manageRule !== void 0) merged.manageRule = schema.manageRule;
   }
-};
+  return merged;
+}
 
 // src/migration/errors.ts
 var MigrationError = class _MigrationError extends Error {
@@ -2193,6 +2302,28 @@ function isAuthCollection(fields) {
   return hasEmail && hasPassword;
 }
 function buildFieldDefinition(fieldName, zodType) {
+  const fieldMetadata = extractFieldMetadata(zodType.description);
+  if (fieldMetadata) {
+    const required2 = isFieldRequired(zodType);
+    const fieldDef2 = {
+      name: fieldName,
+      type: fieldMetadata.type,
+      required: required2,
+      options: fieldMetadata.options
+    };
+    if (fieldMetadata.type === "relation") {
+      const relationMetadata2 = extractRelationMetadata(zodType.description);
+      if (relationMetadata2) {
+        fieldDef2.relation = {
+          collection: relationMetadata2.collection,
+          maxSelect: relationMetadata2.maxSelect,
+          minSelect: relationMetadata2.minSelect,
+          cascadeDelete: relationMetadata2.cascadeDelete
+        };
+      }
+    }
+    return fieldDef2;
+  }
   const fieldType = mapZodTypeToPocketBase(zodType, fieldName);
   const required = isFieldRequired(zodType);
   const options = extractFieldOptions(zodType);
@@ -5319,6 +5450,6 @@ async function executeStatus(options) {
   }
 }
 
-export { CLIUsageError, ConfigurationError, DiffEngine, FIELD_TYPE_INFO, FileSystemError, MigrationError, MigrationGenerationError, MigrationGenerator, POCKETBASE_FIELD_TYPES, PermissionTemplates, ProjectCollection, ProjectInputSchema, ProjectSchema, RelationField, RelationsField, SchemaAnalyzer, SchemaParsingError, SnapshotError, SnapshotManager, StatusEnum, UserCollection, UserCollectionSchema, UserInputSchema, UserMutator, UserSchema, aggregateChanges, baseImageFileSchema, baseSchema, baseSchemaWithTimestamps, boolField, buildFieldDefinition, buildSchemaDefinition, categorizeChangesBySeverity, compare, compareFieldConstraints, compareFieldOptions, compareFieldTypes, comparePermissions, compareRelationConfigurations, convertPocketBaseMigration, convertZodSchemaToCollectionSchema, createMigrationFileStructure, createPermissions, dateField, defineCollection, detectDestructiveChanges, detectFieldChanges, discoverSchemaFiles, editorField, emailField, extractComprehensiveFieldOptions, extractFieldDefinitions, extractFieldOptions, extractIndexes, extractRelationMetadata, extractSchemaDefinitions, fileField, filesField, filterSystemCollections, findLatestSnapshot, findNewCollections, findNewFields, findRemovedCollections, findRemovedFields, formatChangeSummary, generate, generateChangeSummary, generateCollectionCreation, generateCollectionPermissions, generateCollectionRules, generateDownMigration, generateFieldAddition, generateFieldDefinitionObject, generateFieldDeletion, generateFieldModification, generateFieldsArray, generateIndexesArray, executeGenerate as generateMigration, generateMigrationDescription, generateMigrationFilename, generatePermissionUpdate, generateTimestamp, generateUpMigration, geoPointField, getArrayElementType, getCollectionNameFromFile, getDefaultValue, getFieldTypeInfo, getMaxSelect, executeStatus as getMigrationStatus, getMinSelect, getSnapshotPath, getSnapshotVersion, getUsersSystemFields, importSchemaModule, inputImageFileSchema, isArrayType, isAuthCollection, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isPermissionSchema, isRelationField, isSingleRelationField, isSystemCollection, isTemplateConfig, jsonField, loadBaseMigration, loadConfig, loadSnapshot, loadSnapshotIfExists, loadSnapshotWithMigrations, logError, logInfo, logSection, logSuccess, logWarning, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, matchCollectionsByName, matchFieldsByName, mergePermissions, mergeSnapshots, numberField, omitImageFilesSchema, parseSchemaFiles, pluralize, requiresForceFlag, resolveTargetCollection, resolveTemplate, saveSnapshot, selectField, selectSchemaForCollection, singularize, snapshotExists, textField, toCollectionName, unwrapZodType, urlField, validatePermissionConfig, validateRuleExpression, validateSnapshot, withIndexes, withPermissions, withProgress, writeMigrationFile };
+export { AutodateField, BaseMutator, BoolField, CLIUsageError, ConfigurationError, DateField, DiffEngine, EditorField, EmailField, FIELD_METADATA_KEY, FIELD_TYPE_INFO, FileField, FileSystemError, FilesField, GeoPointField, JSONField, MigrationError, MigrationGenerationError, MigrationGenerator, NumberField, POCKETBASE_FIELD_TYPES, PermissionTemplates, RelationField, RelationsField, SchemaAnalyzer, SchemaParsingError, SelectField, SnapshotError, SnapshotManager, StatusEnum, TextField, URLField, aggregateChanges, baseImageFileSchema, baseSchema, baseSchemaWithTimestamps, boolField, buildFieldDefinition, buildSchemaDefinition, categorizeChangesBySeverity, compare, compareFieldConstraints, compareFieldOptions, compareFieldTypes, comparePermissions, compareRelationConfigurations, convertPocketBaseMigration, convertZodSchemaToCollectionSchema, createMigrationFileStructure, createPermissions, dateField, defineCollection, detectDestructiveChanges, detectFieldChanges, discoverSchemaFiles, editorField, emailField, extractComprehensiveFieldOptions, extractFieldDefinitions, extractFieldMetadata, extractFieldOptions, extractIndexes, extractRelationMetadata, extractSchemaDefinitions, fileField, filesField, filterSystemCollections, findLatestSnapshot, findNewCollections, findNewFields, findRemovedCollections, findRemovedFields, formatChangeSummary, generate, generateChangeSummary, generateCollectionCreation, generateCollectionPermissions, generateCollectionRules, generateDownMigration, generateFieldAddition, generateFieldDefinitionObject, generateFieldDeletion, generateFieldModification, generateFieldsArray, generateIndexesArray, executeGenerate as generateMigration, generateMigrationDescription, generateMigrationFilename, generatePermissionUpdate, generateTimestamp, generateUpMigration, geoPointField, getArrayElementType, getCollectionNameFromFile, getDefaultValue, getFieldTypeInfo, getMaxSelect, executeStatus as getMigrationStatus, getMinSelect, getSnapshotPath, getSnapshotVersion, getUsersSystemFields, importSchemaModule, inputImageFileSchema, isArrayType, isAuthCollection, isEditorField, isFieldRequired, isFileFieldByName, isGeoPointType, isMultipleRelationField, isPermissionSchema, isRelationField, isSingleRelationField, isSystemCollection, isTemplateConfig, jsonField, loadBaseMigration, loadConfig, loadSnapshot, loadSnapshotIfExists, loadSnapshotWithMigrations, logError, logInfo, logSection, logSuccess, logWarning, mapZodArrayType, mapZodBooleanType, mapZodDateType, mapZodEnumType, mapZodNumberType, mapZodRecordType, mapZodStringType, mapZodTypeToPocketBase, matchCollectionsByName, matchFieldsByName, mergePermissions, mergeSnapshots, numberField, omitImageFilesSchema, parseSchemaFiles, pluralize, requiresForceFlag, resolveTargetCollection, resolveTemplate, saveSnapshot, selectField, selectSchemaForCollection, singularize, snapshotExists, textField, toCollectionName, unwrapZodType, urlField, validatePermissionConfig, validateRuleExpression, validateSnapshot, withIndexes, withPermissions, withProgress, writeMigrationFile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map