pocketbase-zod-schema 0.2.3 → 0.2.5

package/dist/index.cjs

@@ -42,6 +42,333 @@ var StatusEnum = zod.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: zod.z.string().describe("unique id"),
   collectionId: zod.z.string().describe("collection id"),
@@ -64,762 +391,544 @@ var inputImageFileSchema = {
   imageFiles: zod.z.array(zod.z.instanceof(File))
 };
 var omitImageFilesSchema = {
-  imageFiles: true
-};
-function textField(options) {
-  let schema = zod.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 zod.z.string().email();
-}
-function urlField() {
-  return zod.z.string().url();
-}
-function numberField(options) {
-  let schema = zod.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 zod.z.boolean();
-}
-function dateField() {
-  return zod.z.date();
-}
-function selectField(values) {
-  return zod.z.enum(values);
-}
-function jsonField(schema) {
-  return schema ?? zod.z.record(zod.z.any());
-}
-function fileField() {
-  return zod.z.instanceof(File);
-}
-function filesField(options) {
-  let schema = zod.z.array(zod.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 zod.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 = zod.z.array(zod.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 zod.z.string();
-}
-function geoPointField() {
-  return zod.z.object({
-    lon: zod.z.number(),
-    lat: zod.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 = zod.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 zod.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 zod.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 = zod.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 zod.z.boolean();
+}
+function dateField() {
+  return zod.z.date();
+}
+function selectField(values) {
+  return zod.z.enum(values);
+}
+function jsonField(schema) {
+  return schema ?? zod.z.record(zod.z.any());
+}
+function fileField() {
+  return zod.z.instanceof(File);
+}
+function filesField(options) {
+  let schema = zod.z.array(zod.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 zod.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 = zod.z.array(zod.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 zod.z.string();
 }
-function mergePermissions(...schemas) {
-  const merged = {
-    listRule: null,
-    viewRule: null,
-    createRule: null,
-    updateRule: null,
-    deleteRule: null,
-    manageRule: null
+function geoPointField() {
+  return zod.z.object({
+    lon: zod.z.number(),
+    lat: zod.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 = zod.z.object({
-  // Required fields
-  title: zod.z.string(),
-  content: zod.z.string(),
-  status: StatusEnum,
-  summary: zod.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 = zod.z.object({
-  name: zod.z.string().optional(),
-  email: zod.z.string().email(),
-  password: zod.z.string().min(8, "Password must be at least 8 characters"),
-  passwordConfirm: zod.z.string(),
-  avatar: zod.z.instanceof(File).optional()
-});
-var UserCollectionSchema = zod.z.object({
-  name: zod.z.string().optional(),
-  email: zod.z.string().email(),
-  password: zod.z.string().min(8, "Password must be at least 8 characters"),
-  avatar: zod.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 zod.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 = zod.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 = zod.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 zod.z.string().email().describe(JSON.stringify(metadata));
+}
+function URLField() {
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "url"
+    }
+  };
+  return zod.z.string().url().describe(JSON.stringify(metadata));
+}
+function EditorField() {
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "editor"
+    }
+  };
+  return zod.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 = zod.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 = zod.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 = zod.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 zod.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 = zod.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 = zod.z.array(zod.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 ?? zod.z.record(zod.z.string(), zod.z.any());
+  const metadata = {
+    [FIELD_METADATA_KEY]: {
+      type: "json"
+    }
+  };
+  return baseSchema2.describe(JSON.stringify(metadata));
+}
+function GeoPointField() {
+  const schema = zod.z.object({
+    lon: zod.z.number(),
+    lat: zod.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 {
@@ -2220,6 +2329,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);
@@ -5346,31 +5477,38 @@ async function executeStatus(options) {
   }
 }
 
+exports.AutodateField = AutodateField;
+exports.BaseMutator = BaseMutator;
+exports.BoolField = BoolField;
 exports.CLIUsageError = CLIUsageError;
 exports.ConfigurationError = ConfigurationError;
+exports.DateField = DateField;
 exports.DiffEngine = DiffEngine;
+exports.EditorField = EditorField;
+exports.EmailField = EmailField;
+exports.FIELD_METADATA_KEY = FIELD_METADATA_KEY;
 exports.FIELD_TYPE_INFO = FIELD_TYPE_INFO;
+exports.FileField = FileField;
 exports.FileSystemError = FileSystemError;
+exports.FilesField = FilesField;
+exports.GeoPointField = GeoPointField;
+exports.JSONField = JSONField;
 exports.MigrationError = MigrationError;
 exports.MigrationGenerationError = MigrationGenerationError;
 exports.MigrationGenerator = MigrationGenerator;
+exports.NumberField = NumberField;
 exports.POCKETBASE_FIELD_TYPES = POCKETBASE_FIELD_TYPES;
 exports.PermissionTemplates = PermissionTemplates;
-exports.ProjectCollection = ProjectCollection;
-exports.ProjectInputSchema = ProjectInputSchema;
-exports.ProjectSchema = ProjectSchema;
 exports.RelationField = RelationField;
 exports.RelationsField = RelationsField;
 exports.SchemaAnalyzer = SchemaAnalyzer;
 exports.SchemaParsingError = SchemaParsingError;
+exports.SelectField = SelectField;
 exports.SnapshotError = SnapshotError;
 exports.SnapshotManager = SnapshotManager;
 exports.StatusEnum = StatusEnum;
-exports.UserCollection = UserCollection;
-exports.UserCollectionSchema = UserCollectionSchema;
-exports.UserInputSchema = UserInputSchema;
-exports.UserMutator = UserMutator;
-exports.UserSchema = UserSchema;
+exports.TextField = TextField;
+exports.URLField = URLField;
 exports.aggregateChanges = aggregateChanges;
 exports.baseImageFileSchema = baseImageFileSchema;
 exports.baseSchema = baseSchema;
@@ -5398,6 +5536,7 @@ exports.editorField = editorField;
 exports.emailField = emailField;
 exports.extractComprehensiveFieldOptions = extractComprehensiveFieldOptions;
 exports.extractFieldDefinitions = extractFieldDefinitions;
+exports.extractFieldMetadata = extractFieldMetadata;
 exports.extractFieldOptions = extractFieldOptions;
 exports.extractIndexes = extractIndexes;
 exports.extractRelationMetadata = extractRelationMetadata;