pocketbase-zod-schema 0.2.2 → 0.2.4

package/dist/index.cjs

@@ -42,784 +42,708 @@ var StatusEnum = zod.z.enum([
   "fail"
   // Failed project at any stage
 ]);
-var baseSchema = {
-  id: zod.z.string().describe("unique id"),
-  collectionId: zod.z.string().describe("collection id"),
-  collectionName: zod.z.string().describe("collection name"),
-  expand: zod.z.record(zod.z.any()).describe("expandable fields"),
-  created: zod.z.string().describe("creation timestamp"),
-  updated: zod.z.string().describe("last update timestamp")
-};
-var baseSchemaWithTimestamps = {
-  ...baseSchema,
-  created: zod.z.string().describe("creation timestamp"),
-  updated: zod.z.string().describe("last update timestamp")
-};
-var baseImageFileSchema = {
-  ...baseSchema,
-  thumbnailURL: zod.z.string().optional(),
-  imageFiles: zod.z.array(zod.z.string())
-};
-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
-    }
+var BaseMutator = class {
+  pb;
+  // Define a default property that subclasses will override
+  options = {
+    expand: [],
+    filter: [],
+    sort: []
   };
-  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
+  constructor(pb, options) {
+    this.pb = pb;
+    this.initializeOptions();
+    if (options) {
+      this.overrideOptions(options);
     }
-  };
-  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);
+  initializeOptions() {
+    this.options = this.setDefaults();
   }
-  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 {
+  /**
+   * Initialize options with class-specific defaults
+   * Subclasses should override this instead of directly setting options
+   */
+  setDefaults() {
+    return {
+      expand: [],
+      filter: [],
+      sort: []
+    };
   }
-  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 {
+  /**
+   * 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;
     }
   }
-  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;
+  toSnakeCase(str) {
+    return str.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
   }
-  if (permissions) {
-    metadata.permissions = permissions;
+  /**
+   * 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);
+    }
   }
-  if (indexes) {
-    metadata.indexes = indexes;
+  /**
+   * 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);
+    }
   }
-  if (Object.keys(futureOptions).length > 0) {
-    Object.assign(metadata, futureOptions);
+  /**
+   * Create or update entity (upsert)
+   */
+  async upsert(input) {
+    if (input?.id) {
+      return await this.update(input.id, input);
+    }
+    return await this.create(input);
   }
-  return schema.describe(JSON.stringify(metadata));
-}
-
-// src/utils/permission-templates.ts
-var PermissionTemplates = {
   /**
-   * Public access - anyone can perform all operations
+   * Get entity by ID
    */
-  public: () => ({
-    listRule: "",
-    viewRule: "",
-    createRule: "",
-    updateRule: "",
-    deleteRule: ""
-  }),
+  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 });
+    }
+  }
   /**
-   * Authenticated users only - requires valid authentication for all operations
+   * Get first entity by filter
    */
-  authenticated: () => ({
-    listRule: '@request.auth.id != ""',
-    viewRule: '@request.auth.id != ""',
-    createRule: '@request.auth.id != ""',
-    updateRule: '@request.auth.id != ""',
-    deleteRule: '@request.auth.id != ""'
-  }),
+  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 });
+    }
+  }
   /**
-   * Owner-only access - users can only manage their own records
-   * @param ownerField - Name of the relation field pointing to user (default: 'User')
+   * Get list of entities
    */
-  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`
-  }),
+  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);
+    }
+  }
   /**
-   * Admin/superuser only access
-   * Assumes a 'role' field exists with 'admin' value
-   * @param roleField - Name of the role field (default: 'role')
+   * Delete entity by ID
    */
-  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"`
-  }),
+  async delete(id) {
+    try {
+      return await this.entityDelete(id);
+    } catch (error) {
+      return this.handleError(error, { returnValue: false });
+    }
+  }
   /**
-   * Public read, authenticated write
-   * Anyone can list/view, but only authenticated users can create/update/delete
+   * Process a single record before returning it
+   * Can be overridden to handle special cases like mapped entities
    */
-  readPublic: () => ({
-    listRule: "",
-    viewRule: "",
-    createRule: '@request.auth.id != ""',
-    updateRule: '@request.auth.id != ""',
-    deleteRule: '@request.auth.id != ""'
-  }),
+  async processRecord(record) {
+    return record;
+  }
   /**
-   * Locked access - only superusers can perform operations
-   * All rules are set to null (locked)
+   * Process a list result before returning it
+   * Can be overridden to handle special cases like mapped entities
    */
-  locked: () => ({
-    listRule: null,
-    viewRule: null,
-    createRule: null,
-    updateRule: null,
-    deleteRule: null
-  }),
+  async processListResult(result) {
+    const processedItems = await Promise.all(result.items.map((item) => this.processRecord(item)));
+    return {
+      ...result,
+      items: processedItems
+    };
+  }
   /**
-   * Read-only authenticated - authenticated users can read, no write access
+   * Prepare expand parameter
+   * Combines default expands with provided expands
    */
-  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}`);
+  prepareExpand(expand) {
+    if (!this.options.expand.length && !expand) {
+      return void 0;
     }
-  }
-  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'");
+    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);
+      }
     }
-    if (config.template === "admin-only" && !config.roleField) {
-      result.warnings.push("admin-only template without roleField specified - using default 'role'");
+    const uniqueExpands = [...new Set(expandArray)].filter((e) => e !== "" && e !== void 0);
+    if (!uniqueExpands.length) {
+      return void 0;
     }
-    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");
+    return uniqueExpands.join(",");
   }
-  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;
+  /**
+   * 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);
       }
-      result.warnings.push(...ruleValidation.warnings.map((w) => `${ruleType}: ${w}`));
     }
-  }
-  return result;
-}
-function validateRuleExpression(expression) {
-  const result = {
-    valid: true,
-    errors: [],
-    warnings: []
-  };
-  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;
+    const validFilters = filterArray.filter((f) => f !== "" && f !== void 0);
+    if (!validFilters.length) {
+      return void 0;
     }
+    return validFilters.join("&&");
   }
-  if (parenCount !== 0) {
-    result.errors.push("Unbalanced parentheses");
-    result.valid = false;
-  }
-  if (expression.includes("==")) {
-    result.warnings.push("Use '=' instead of '==' for equality comparison");
-  }
-  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;
+  /**
+   * 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;
   }
-  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;
+  /**
+   * Perform the actual create operation
+   */
+  async entityCreate(data) {
+    return await this.getCollection().create(data);
   }
-  return merged;
-}
-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)'
-    }
+  /**
+   * Perform the actual update operation
+   */
+  async entityUpdate(id, data) {
+    return await this.getCollection().update(id, data);
   }
-});
-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: []
-  };
-  constructor(pb, options) {
-    this.pb = pb;
-    this.initializeOptions();
-    if (options) {
-      this.overrideOptions(options);
-    }
+  /**
+   * 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);
   }
-  initializeOptions() {
-    this.options = this.setDefaults();
+  /**
+   * 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);
   }
   /**
-   * Initialize options with class-specific defaults
-   * Subclasses should override this instead of directly setting options
+   * Perform the actual getList operation
+   * Returns a list result with items of type T
    */
-  setDefaults() {
-    return {
-      expand: [],
-      filter: [],
-      sort: []
-    };
+  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);
   }
   /**
-   * Merge provided options with current options
+   * Perform the actual delete operation
    */
-  overrideOptions(newOptions) {
-    if (newOptions.expand !== void 0) {
-      this.options.expand = newOptions.expand;
+  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 (newOptions.filter !== void 0) {
-      this.options.filter = newOptions.filter;
+    if (allowNotFound && this.isNotFoundError(error)) {
+      return null;
     }
-    if (newOptions.sort !== void 0) {
-      this.options.sort = newOptions.sort;
+    if (returnValue !== void 0) {
+      return returnValue;
     }
+    throw error;
   }
-  toSnakeCase(str) {
-    return str.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  /**
+   * 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"));
   }
   /**
-   * Create a new entity
+   * Standard error handling wrapper (legacy method, consider using handleError instead)
    */
-  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);
-    }
+  errorWrapper(error) {
+    console.error(`Error in ${this.constructor.name}:`, error);
+    throw error;
   }
   /**
-   * Update an existing entity
+   * 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 update(id, input) {
-    try {
-      const record = await this.entityUpdate(id, input);
-      return await this.processRecord(record);
-    } catch (error) {
-      return this.errorWrapper(error);
-    }
+  async subscribeToRecord(id, callback, expand) {
+    const finalExpand = this.prepareExpand(expand);
+    const options = finalExpand ? { expand: finalExpand } : {};
+    return this.getCollection().subscribe(id, callback, options);
   }
   /**
-   * Create or update entity (upsert)
+   * 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 upsert(input) {
-    if (input?.id) {
-      return await this.update(input.id, input);
+  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"),
+  collectionName: zod.z.string().describe("collection name"),
+  expand: zod.z.record(zod.z.any()).describe("expandable fields"),
+  created: zod.z.string().describe("creation timestamp"),
+  updated: zod.z.string().describe("last update timestamp")
+};
+var baseSchemaWithTimestamps = {
+  ...baseSchema,
+  created: zod.z.string().describe("creation timestamp"),
+  updated: zod.z.string().describe("last update timestamp")
+};
+var baseImageFileSchema = {
+  ...baseSchema,
+  thumbnailURL: zod.z.string().optional(),
+  imageFiles: zod.z.array(zod.z.string())
+};
+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 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 });
+  };
+  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);
   }
-  /**
-   * 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 });
-    }
+  if (config.maxSelect !== void 0) {
+    schema = schema.max(config.maxSelect);
   }
-  /**
-   * 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 extractRelationMetadata(description) {
+  if (!description) return null;
+  try {
+    const parsed = JSON.parse(description);
+    if (parsed[RELATION_METADATA_KEY]) {
+      return parsed[RELATION_METADATA_KEY];
     }
+  } catch {
   }
-  /**
-   * Delete entity by ID
-   */
-  async delete(id) {
+  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 {
-      return await this.entityDelete(id);
-    } catch (error) {
-      return this.handleError(error, { returnValue: false });
+      existingMetadata = JSON.parse(schema.description);
+    } catch {
     }
   }
-  /**
-   * 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
-    };
+  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;
   }
-  /**
-   * 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(",");
+  if (permissions) {
+    metadata.permissions = permissions;
   }
-  /**
-   * 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("&&");
+  if (indexes) {
+    metadata.indexes = indexes;
   }
-  /**
-   * 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;
+  if (Object.keys(futureOptions).length > 0) {
+    Object.assign(metadata, futureOptions);
   }
+  return schema.describe(JSON.stringify(metadata));
+}
+
+// src/utils/permission-templates.ts
+var PermissionTemplates = {
   /**
-   * Perform the actual create operation
+   * Public access - anyone can perform all operations
    */
-  async entityCreate(data) {
-    return await this.getCollection().create(data);
-  }
+  public: () => ({
+    listRule: "",
+    viewRule: "",
+    createRule: "",
+    updateRule: "",
+    deleteRule: ""
+  }),
   /**
-   * Perform the actual update operation
+   * Authenticated users only - requires valid authentication for all operations
    */
-  async entityUpdate(id, data) {
-    return await this.getCollection().update(id, data);
-  }
+  authenticated: () => ({
+    listRule: '@request.auth.id != ""',
+    viewRule: '@request.auth.id != ""',
+    createRule: '@request.auth.id != ""',
+    updateRule: '@request.auth.id != ""',
+    deleteRule: '@request.auth.id != ""'
+  }),
   /**
-   * Perform the actual getById operation
+   * Owner-only access - users can only manage their own records
+   * @param ownerField - Name of the relation field pointing to user (default: 'User')
    */
-  async entityGetById(id, expand) {
-    const finalExpand = this.prepareExpand(expand);
-    const options = finalExpand ? { expand: finalExpand } : {};
-    return await this.getCollection().getOne(id, 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`
+  }),
   /**
-   * Perform the actual getFirstByFilter operation
+   * Admin/superuser only access
+   * Assumes a 'role' field exists with 'admin' value
+   * @param roleField - Name of the role field (default: 'role')
    */
-  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);
-  }
+  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 {
@@ -4009,6 +3933,55 @@ function generateIndexesArray(indexes) {
     ${indexStrings.join(",\n    ")},
   ]`;
 }
+function getSystemFields() {
+  return [
+    // id field - primary key, auto-generated
+    {
+      name: "id",
+      type: "text",
+      required: true,
+      options: {
+        autogeneratePattern: "[a-z0-9]{15}",
+        hidden: false,
+        id: "text3208210256",
+        max: 15,
+        min: 15,
+        pattern: "^[a-z0-9]+$",
+        presentable: false,
+        primaryKey: true,
+        system: true
+      }
+    },
+    // created field - autodate, set on creation
+    {
+      name: "created",
+      type: "autodate",
+      required: true,
+      options: {
+        hidden: false,
+        id: "autodate2990389176",
+        onCreate: true,
+        onUpdate: false,
+        presentable: false,
+        system: false
+      }
+    },
+    // updated field - autodate, set on creation and update
+    {
+      name: "updated",
+      type: "autodate",
+      required: true,
+      options: {
+        hidden: false,
+        id: "autodate3332085495",
+        onCreate: true,
+        onUpdate: true,
+        presentable: false,
+        system: false
+      }
+    }
+  ];
+}
 function generateCollectionCreation(collection, varName = "collection", isLast = false) {
   const lines = [];
   lines.push(`  const ${varName} = new Collection({`);
@@ -4021,7 +3994,9 @@ function generateCollectionCreation(collection, varName = "collection", isLast =
   } else if (rulesCode) {
     lines.push(`    ${rulesCode},`);
   }
-  lines.push(`    fields: ${generateFieldsArray(collection.fields)},`);
+  const systemFields = getSystemFields();
+  const allFields = [...systemFields, ...collection.fields];
+  lines.push(`    fields: ${generateFieldsArray(allFields)},`);
   lines.push(`    indexes: ${generateIndexesArray(collection.indexes)},`);
   lines.push(`  });`);
   lines.push(``);
@@ -5295,6 +5270,7 @@ async function executeStatus(options) {
   }
 }
 
+exports.BaseMutator = BaseMutator;
 exports.CLIUsageError = CLIUsageError;
 exports.ConfigurationError = ConfigurationError;
 exports.DiffEngine = DiffEngine;
@@ -5305,9 +5281,6 @@ exports.MigrationGenerationError = MigrationGenerationError;
 exports.MigrationGenerator = MigrationGenerator;
 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;
@@ -5315,11 +5288,6 @@ exports.SchemaParsingError = SchemaParsingError;
 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.aggregateChanges = aggregateChanges;
 exports.baseImageFileSchema = baseImageFileSchema;
 exports.baseSchema = baseSchema;