pocketbase-zod-schema 0.3.9 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.4.0](https://github.com/dastron/pocketbase-zod-schema/compare/pocketbase-zod-schema-v0.3.9...pocketbase-zod-schema-v0.4.0) (2026-01-19)
+
+
+### Features
+
+* add strongly typed expand support and type generation CLI ([2ca3f39](https://github.com/dastron/pocketbase-zod-schema/commit/2ca3f39d0af6bcf92f212ed64bab20e368c1297d))
+* add strongly typed expand support and type generation CLI ([f8a1b4b](https://github.com/dastron/pocketbase-zod-schema/commit/f8a1b4bfbe3da3fc5b98977b53bc211fb3d44f0d))
+
 ## [0.3.9](https://github.com/dastron/pocketbase-zod-schema/compare/pocketbase-zod-schema-v0.3.8...pocketbase-zod-schema-v0.3.9) (2026-01-19)
 
 

package/dist/cli/migrate.cjs

@@ -179,10 +179,10 @@ var FileSystemError = class _FileSystemError extends MigrationError {
   operation;
   code;
   originalError;
-  constructor(message, path7, operation, code, originalError) {
+  constructor(message, path8, operation, code, originalError) {
     super(message);
     this.name = "FileSystemError";
-    this.path = path7;
+    this.path = path8;
     this.operation = operation;
     this.code = code;
     this.originalError = originalError;
@@ -4245,6 +4245,184 @@ Examples:
 `
   ).action(executeGenerate);
 }
+
+// src/type-gen/generator.ts
+var TypeGenerator = class {
+  schema;
+  constructor(schema) {
+    this.schema = schema;
+  }
+  generate() {
+    const lines = [];
+    lines.push(`/**`);
+    lines.push(` * This file was auto-generated by pocketbase-zod-schema.`);
+    lines.push(` * Do not modify it manually.`);
+    lines.push(` */`);
+    lines.push(``);
+    lines.push(`import type { RecordModel } from "pocketbase";`);
+    lines.push(``);
+    const collectionNames = Array.from(this.schema.collections.keys());
+    for (const [_, collection] of this.schema.collections) {
+      lines.push(this.generateCollectionType(collection));
+      lines.push(``);
+    }
+    lines.push(`export type CollectionResponses = {`);
+    for (const name of collectionNames) {
+      const typeName = this.toPascalCase(name);
+      lines.push(`  ${name}: ${typeName}Response;`);
+    }
+    lines.push(`};`);
+    lines.push(``);
+    lines.push(`import PocketBase from "pocketbase";`);
+    lines.push(`import { RecordService } from "pocketbase";`);
+    lines.push(``);
+    lines.push(`export interface TypedPocketBase extends PocketBase {`);
+    lines.push(`  collection(idOrName: string): RecordService;`);
+    for (const name of collectionNames) {
+      const typeName = this.toPascalCase(name);
+      lines.push(`  collection(idOrName: "${name}"): RecordService<${typeName}Response>;`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+    return lines.join("\n");
+  }
+  generateCollectionType(collection) {
+    const typeName = this.toPascalCase(collection.name);
+    const lines = [];
+    lines.push(`export interface ${typeName}Record {`);
+    lines.push(`  id: string;`);
+    lines.push(`  created: string;`);
+    lines.push(`  updated: string;`);
+    lines.push(`  collectionId: string;`);
+    lines.push(`  collectionName: "${collection.name}";`);
+    for (const field of collection.fields) {
+      if (["id", "created", "updated"].includes(field.name)) continue;
+      const fieldType = this.getFieldType(field);
+      const optional = !field.required ? "?" : "";
+      lines.push(`  ${field.name}${optional}: ${fieldType};`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`export interface ${typeName}Response extends ${typeName}Record {`);
+    const expandFields = [];
+    for (const field of collection.fields) {
+      if (field.type === "relation" && field.relation) {
+        const targetCollection = field.relation.collection;
+        let targetType = "RecordModel";
+        if (targetCollection.toLowerCase() === "users" && !this.schema.collections.has("users")) ;
+        if (this.schema.collections.has(targetCollection)) {
+          targetType = `${this.toPascalCase(targetCollection)}Response`;
+        } else if (targetCollection === "users") {
+          targetType = "RecordModel";
+        }
+        const isMultiple = (field.relation.maxSelect ?? 1) > 1;
+        const expandType = isMultiple ? `${targetType}[]` : targetType;
+        expandFields.push(`${field.name}?: ${expandType}`);
+      }
+    }
+    if (expandFields.length > 0) {
+      lines.push(`  expand?: {`);
+      for (const ef of expandFields) {
+        lines.push(`    ${ef};`);
+      }
+      lines.push(`  };`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+  }
+  getFieldType(field) {
+    switch (field.type) {
+      case "text":
+      case "email":
+      case "url":
+      case "editor":
+      case "date":
+      case "autodate":
+        return "string";
+      case "number":
+        return "number";
+      case "bool":
+        return "boolean";
+      case "json":
+        return "any";
+      case "file":
+        if (field.options?.maxSelect && field.options.maxSelect > 1) {
+          return "string[]";
+        }
+        return "string";
+      case "select":
+        if (field.options?.values && Array.isArray(field.options.values) && field.options.values.length > 0) {
+          const union = field.options.values.map((v) => `"${v}"`).join(" | ");
+          if (field.options?.maxSelect && field.options.maxSelect > 1) {
+            return `(${union})[]`;
+          }
+          return union;
+        }
+        if (field.options?.maxSelect && field.options.maxSelect > 1) {
+          return "string[]";
+        }
+        return "string";
+      case "relation":
+        if (field.relation?.maxSelect && field.relation.maxSelect > 1) {
+          return "string[]";
+        }
+        return "string";
+      default:
+        return "any";
+    }
+  }
+  toPascalCase(str) {
+    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => {
+      return word.toUpperCase();
+    }).replace(/[\s_-]+/g, "");
+  }
+};
+
+// src/cli/commands/generate-types.ts
+async function executeGenerateTypes(options) {
+  try {
+    const parentOpts = options.parent?.opts?.() || {};
+    if (parentOpts.verbose) {
+      setVerbosity("verbose");
+    } else if (parentOpts.quiet) {
+      setVerbosity("quiet");
+    }
+    logDebug("Starting type generation...");
+    logDebug(`Options: ${JSON.stringify(options, null, 2)}`);
+    const config = await loadConfig(options);
+    const schemaDir = getSchemaDirectory(config);
+    logSection("\u{1F50D} Analyzing Schema");
+    const analyzerConfig = {
+      schemaDir,
+      excludePatterns: config.schema.exclude,
+      useCompiledFiles: false
+    };
+    const currentSchema = await withProgress("Parsing Zod schemas...", () => parseSchemaFiles(analyzerConfig));
+    logSuccess(`Found ${currentSchema.collections.size} collection(s)`);
+    logSection("\u{1F4DD} Generating Types");
+    const generator = new TypeGenerator(currentSchema);
+    const output = await withProgress("Generating TypeScript definitions...", () => Promise.resolve(generator.generate()));
+    const outputPath = options.output || "pocketbase-types.ts";
+    const resolvedPath = path5__namespace.resolve(process.cwd(), outputPath);
+    fs5__namespace.writeFileSync(resolvedPath, output);
+    logSuccess(`Types generated successfully at: ${outputPath}`);
+    logSection("\u2705 Next Steps");
+    console.log();
+    console.log("  1. Import types in your application:");
+    console.log(`     import { TypedPocketBase } from "./${path5__namespace.basename(outputPath).replace(/\.ts$/, "")}";`);
+    console.log();
+  } catch (error) {
+    logError(`Failed to generate types: ${error}`);
+    if (error instanceof Error && error.stack) {
+      console.error();
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+function createGenerateTypesCommand() {
+  return new commander.Command("generate-types").description("Generate TypeScript definitions from Zod schemas").option("-o, --output <path>", "Output file path", "pocketbase-types.ts").option("--schema-dir <directory>", "Directory containing Zod schema files").action(executeGenerateTypes);
+}
 function hasChanges3(diff) {
   return diff.collectionsToCreate.length > 0 || diff.collectionsToDelete.length > 0 || diff.collectionsToModify.length > 0;
 }
@@ -4487,6 +4665,7 @@ program.name("pocketbase-migrate").description(
   }
 });
 program.addCommand(createGenerateCommand());
+program.addCommand(createGenerateTypesCommand());
 program.addCommand(createStatusCommand());
 program.addHelpText(
   "after",
@@ -4494,6 +4673,7 @@ program.addHelpText(
 ${chalk__default.default.bold("Examples:")}
   $ pocketbase-migrate status              Check for pending schema changes
   $ pocketbase-migrate generate            Generate migration from schema changes
+  $ pocketbase-migrate generate-types      Generate TypeScript definitions
   $ pocketbase-migrate generate --force    Generate migration with destructive changes
   $ pocketbase-migrate --help              Show this help message