migrate from eslint & prettier to biome

.zed/settings.json

@@ -0,0 +1,9 @@
+{
+	"lsp": {
+		"biome": {
+			"settings": {
+				"config_path": "./biome.json"
+			}
+		}
+	}
+}

README.md

@@ -1,9 +1,32 @@
-# zod-pocketbase
+# zod-pocketbase-continued
 
-Zod tooling for your Pocketbase instance.
+Zod tooling for your PocketBase instance.
 
-To see how to get started, check out the [docs](https://zod-pocketbase.vercel.app)
+This repository is a continuation of [Gregory Bouteiller's zod-pocketbase](https://github.com/gbouteiller/zod-pocketbase), as the original repository was outdated for 10 months.
 
-## Licensing
+## Documentation
 
-[MIT Licensed](./LICENSE). Made with ❤️ by [Gregory Bouteiller](https://github.com/gbouteiller).
+[Old documentation is compatible with the current version](https://zod-pocketbase.vercel.app)
+
+## Compatibility
+
+- **PocketBase**: v0.30.0
+- **PocketBase JS SDK**: v0.26.2
+
+## Changes from Original
+
+### Project Structure
+- Removed `doc/`, `playground/` and monorepo configuration
+- Replaced `pnpm` and `node` in favor of `bun`
+- Switched `.github/` to `.gitea/` and `gh` to `tea`
+
+### Dependencies & Code
+- Migrated from `tsup` to `tsdown`
+- Updated all npm dependencies (except `zod`, which was only updated to the latest 3 version)
+- Removed unused dependencies
+- Fixed `getPocketbase` function in `sdk.ts` to match the latest PocketBase version
+- Implemented most TODOs left in `content.ts`
+
+## License
+
+[MIT License](./LICENSE)

assets/stubs/index.ts

@@ -33,6 +33,41 @@ export const RecordModel = z.object({
 });
 export type RecordModel = z.infer<typeof RecordModel>;
 
+/******* JSON FIELD *******/
+export const pbJsonField = (maxSizeInBytes: number = 1048576) => {
+  const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+  const jsonSchema: z.ZodType<any> = z.lazy(() =>
+    z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)])
+  );
+
+  const stringTransform = z.string()
+    .max(maxSizeInBytes, `JSON field cannot exceed ${maxSizeInBytes} bytes`)
+    .transform((val: string) => {
+      if (val === "true") return true;
+      if (val === "false") return false;
+      if (val === "null") return null;
+
+      if ((val.startsWith('[') && val.endsWith(']'))||(val.startsWith('{') && val.endsWith('}')))
+        try {
+          return JSON.parse(val);
+        } catch {
+          return val;
+        }
+
+      const num = Number(val);
+      if (!Number.isNaN(num) && Number.isFinite(num) && val.trim() !== '')
+        return num;
+
+      if (val.startsWith('"') && val.endsWith('"'))
+        return val.slice(1, -1);
+
+      return val;
+    });
+
+  return z.union([jsonSchema, stringTransform]);
+};
+
+
 /******* RECORDS *******/
 @@_RECORDS_@@
 

biome.json

@@ -0,0 +1,41 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.2.6/schema.json",
+	"vcs": { "enabled": false, "clientKind": "git", "useIgnoreFile": false },
+	"files": {
+		"ignoreUnknown": false,
+		"includes": ["**", "!**/node_modules", "!**/assets/stubs/index.ts"]
+	},
+	"formatter": {
+		"enabled": true,
+		"formatWithErrors": false,
+		"indentStyle": "tab",
+		"indentWidth": 2,
+		"lineEnding": "lf",
+		"lineWidth": 100,
+		"attributePosition": "auto",
+		"bracketSameLine": false,
+		"bracketSpacing": true,
+		"expand": "auto",
+		"useEditorconfig": true
+	},
+	"linter": { "enabled": true, "rules": { "recommended": false } },
+	"javascript": {
+		"formatter": {
+			"jsxQuoteStyle": "double",
+			"quoteProperties": "asNeeded",
+			"trailingCommas": "all",
+			"semicolons": "asNeeded",
+			"arrowParentheses": "always",
+			"bracketSameLine": false,
+			"quoteStyle": "single",
+			"attributePosition": "auto",
+			"bracketSpacing": true
+		}
+	},
+	"html": { "formatter": { "selfCloseVoidElements": "always" } },
+	"overrides": [{ "includes": ["**/*.ts", "**/*.tsx"] }],
+	"assist": {
+		"enabled": true,
+		"actions": { "source": { "organizeImports": "on" } }
+	}
+}

eslint.config.mjs

@@ -1,3 +0,0 @@
-import astro from "eslint-plugin-astro";
-
-export default [...astro.configs["flat/recommended"], ...astro.configs["flat/jsx-a11y-strict"]];

flake.nix

@@ -1,5 +1,5 @@
 {
-  description = "Zod-PocketBase development environment with Bun";
+  description = "Zod-PocketBase-Continue development environment with Bun";
 
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
@@ -30,7 +30,7 @@
           ];
 
           shellHook = ''
-            echo "🚀 Zod-PocketBase development environment (Bun-powered)"
+            echo "🚀 Zod-PocketBase-Continue development environment (Bun-powered)"
             echo "Bun version: $(bun --version)"
             echo "Tea version: $(tea --version)"
             echo ""
@@ -52,7 +52,7 @@
         };
 
         packages.default = pkgs.stdenv.mkDerivation {
-          name = "zod-pocketbase";
+          name = "zod-pocketbase-continue";
           src = ./.;
 
           buildInputs = [ bun ];

package.json

@@ -1,22 +1,15 @@
 {
-  "name": "zod-pocketbase",
+	"name": "zod-pocketbase-continue",
-  "version": "0.5.0",
+	"version": "0.5.1",
-  "description": "",
+	"description": "Zod tooling for your PocketBase instance.",
 	"author": {
 		"email": "garandplg@garandplg.com",
 		"name": "Garand_PLG",
 		"url": "https://gitea.garandplg.com"
 	},
 	"license": "MIT",
-  "keywords": [
+	"keywords": ["pocketbase", "schemas", "typescript", "typegen", "type generation", "zod"],
-    "pocketbase",
+	"homepage": "https://gitea.garandplg.com/GarandPLG/zod-pocketbase-continue",
-    "schemas",
-    "typescript",
-    "typegen",
-    "type generation",
-    "zod"
-  ],
-  "homepage": "https://gitea.garandplg.com/GarandPLG/zod-pocketbase",
 	"publishConfig": {
 		"access": "public"
 	},
@@ -28,7 +21,7 @@
 	},
 	"main": "dist/index.js",
 	"bin": {
-    "zod-pocketbase": "dist/server/cli.js"
+		"zod-pocketbase-continue": "dist/server/cli.js"
 	},
 	"exports": {
 		".": {
@@ -40,38 +33,33 @@
 			"default": "./dist/server/index.js"
 		}
 	},
-  "files": [
+	"files": ["dist", "assets"],
-    "dist",
-    "assets"
-  ],
 	"scripts": {
-    "dev": "tsup --watch",
+		"dev": "tsdown --watch",
-    "build": "tsup",
+		"build": "tsdown",
 		"changeset": "changeset",
-    "release": "bun scripts/release.mjs"
+		"release": "bun scripts/release.mjs",
+		"lint": "biome check .",
+		"lint:w": "biome check --write .",
+		"format": "biome format .",
+		"format:w": "biome format --write ."
 	},
 	"dependencies": {
-    "@clack/prompts": "^0.9.0",
+		"@clack/prompts": "^0.11.0",
-    "c12": "^2.0.1",
+		"c12": "^3.3.0",
 		"citty": "^0.1.6",
-    "es-toolkit": "^1.30.1"
+		"es-toolkit": "^1.40.0"
 	},
 	"devDependencies": {
-    "@changesets/cli": "^2.27.11",
+		"@biomejs/biome": "2.2.6",
-    "@types/node": "^22.10.2",
+		"@changesets/cli": "^2.29.7",
-    "@typescript-eslint/parser": "^8.18.1",
+		"@types/node": "^24.7.1",
-    "eslint": "^9.17.0",
+		"pocketbase": "^0.26.2",
-    "eslint-plugin-astro": "^1.3.1",
+		"tsdown": "^0.15.6",
-    "eslint-plugin-jsx-a11y": "^6.10.2",
+		"zod": "^3.25.76"
-    "pocketbase": "<0.22.0",
-    "prettier": "^3.4.2",
-    "prettier-plugin-astro": "^0.14.1",
-    "prettier-plugin-tailwindcss": "^0.6.9",
-    "tsup": "^8.3.5",
-    "zod": "^3.24.1"
 	},
 	"peerDependencies": {
-    "pocketbase": "<0.22.0",
+		"pocketbase": "^0.26.2",
-    "zod": "^3.23.8"
+		"zod": "^3.25.76"
 	}
 }

prettier.config.mjs

@@ -1,6 +0,0 @@
-/** @type {import("prettier").Config} */
-export default {
-  printWidth: 140,
-  plugins: ["prettier-plugin-astro", "prettier-plugin-tailwindcss"],
-  overrides: [{ files: "*.astro", options: { parser: "astro" } }],
-};

scripts/release.mjs

@@ -1,5 +1,5 @@
-import { spawn } from "node:child_process";
+import { spawn } from 'node:child_process'
-import { resolve } from "node:path";
+import { resolve } from 'node:path'
 
 /**
  *
@@ -9,41 +9,41 @@ import { resolve } from "node:path";
  * @returns {Promise<string>}
  */
 const run = async (command, ...args) => {
-  const cwd = resolve();
+	const cwd = resolve()
 	return new Promise((resolve) => {
 		const cmd = spawn(command, args, {
-      stdio: ["inherit", "pipe", "pipe"], // Inherit stdin, pipe stdout, pipe stderr
+			stdio: ['inherit', 'pipe', 'pipe'], // Inherit stdin, pipe stdout, pipe stderr
 			shell: true,
 			cwd,
-    });
+		})
 
-    let output = "";
+		let output = ''
 
-    cmd.stdout.on("data", (data) => {
+		cmd.stdout.on('data', (data) => {
-      process.stdout.write(data.toString());
+			process.stdout.write(data.toString())
-      output += data.toString();
+			output += data.toString()
-    });
+		})
 
-    cmd.stderr.on("data", (data) => {
+		cmd.stderr.on('data', (data) => {
-      process.stderr.write(data.toString());
+			process.stderr.write(data.toString())
-    });
+		})
 
-    cmd.on("close", () => {
+		cmd.on('close', () => {
-      resolve(output);
+			resolve(output)
-    });
+		})
-  });
+	})
-};
+}
 
 const main = async () => {
-  await run("bun changeset version");
+	await run('bun changeset version')
-  await run("git add .");
+	await run('git add .')
-  await run('git commit -m "chore: update version"');
+	await run('git commit -m "chore: update version"')
-  await run("git push");
+	await run('git push')
-  await run("bun run build");
+	await run('bun run build')
-  await run("bun changeset publish");
+	await run('bun changeset publish')
-  await run("git push --follow-tags");
+	await run('git push --follow-tags')
-  const tag = (await run("git describe --abbrev=0")).replace("\n", "");
+	const tag = (await run('git describe --abbrev=0')).replace('\n', '')
-  await run(`tea releases create --tag ${tag} --title "${tag}"`);
+	await run(`tea releases create --tag ${tag} --title "${tag}"`)
-};
+}
 
-main();
+main()

src/config.ts

@@ -1,5 +1,5 @@
-import { pascalCase, snakeCase } from "es-toolkit";
+import { pascalCase, snakeCase } from 'es-toolkit'
-import { z } from "zod";
+import { z } from 'zod'
 
 /**
  * Default config values.
@@ -7,14 +7,15 @@ import { z } from "zod";
 export const defaultConfig = {
 	ignore: [],
 	nameEnum: (name: string) => snakeCase(name).toUpperCase(),
-  nameEnumField: (collectionName: string, fieldName: string) => `${collectionName}${pascalCase(fieldName)}`,
+	nameEnumField: (collectionName: string, fieldName: string) =>
+		`${collectionName}${pascalCase(fieldName)}`,
 	nameEnumSchema: (name: string) => pascalCase(name),
 	nameEnumType: (name: string) => pascalCase(name),
 	nameEnumValues: (name: string) => `${name}Values`,
 	nameRecordSchema: (name: string) => `${pascalCase(name)}Record`,
 	nameRecordType: (name: string) => `${pascalCase(name)}Record`,
-  output: "./zod-pocketbase.ts",
+	output: './zod-pocketbase-continue.ts',
-};
+}
 
 /**
  * Schema for the PocketBase credentials.
@@ -23,8 +24,8 @@ export const Credentials = z.object({
 	adminEmail: z.string().email(),
 	adminPassword: z.string(),
 	url: z.string().url(),
-});
+})
-export type Credentials = z.infer<typeof Credentials>;
+export type Credentials = z.infer<typeof Credentials>
 
 /**
  * Schema for the config file.
@@ -61,6 +62,6 @@ export const Config = z.object({
 		.optional()
 		.transform((f) => f ?? defaultConfig.nameRecordType),
 	output: z.string().default(defaultConfig.output),
-});
+})
-export type Config = z.input<typeof Config>;
+export type Config = z.input<typeof Config>
-export type ResolvedConfig = z.infer<typeof Config>;
+export type ResolvedConfig = z.infer<typeof Config>

src/content.ts

@@ -1,120 +1,199 @@
-import { sortBy } from "es-toolkit";
+import { sortBy } from 'es-toolkit'
-import type { CollectionModel, SchemaField } from "pocketbase";
+import type { CollectionField, CollectionModel } from 'pocketbase'
-import type { GenerateOpts } from "./server/utils.ts";
+import type { GenerateOpts } from '@/server/utils.ts'
 
 export function stringifyContent(collections: CollectionModel[], opts: GenerateOpts) {
 	function getCollectionSelectFields() {
 		return collections.flatMap((collection) =>
-      collection.schema
+			collection.fields
-        .filter((field) => field.type === "select")
+				.filter((field: CollectionField) => field.type === 'select')
-        .map((field) => ({ name: opts.nameEnumField(collection.name, field.name), values: (field.options.values ?? []) as string[] })),
+				.map((field: CollectionField) => ({
-    );
+					name: opts.nameEnumField(collection.name, field.name),
+					values: ((field as any).values ?? []) as string[],
+				})),
+		)
 	}
 
 	function stringifyEnum({ name, values }: SelectField) {
-    const valuesName = opts.nameEnumValues(name);
+		const valuesName = opts.nameEnumValues(name)
-    const schemaName = opts.nameEnumSchema(name);
+		const schemaName = opts.nameEnumSchema(name)
-    const enumName = opts.nameEnum(name);
+		const enumName = opts.nameEnum(name)
-    const typeName = opts.nameEnumType(name);
+		const typeName = opts.nameEnumType(name)
-    return `export const ${valuesName} = [\n\t${values.map((value) => `"${value}"`).join(",\n\t")},\n] as const;\nexport const ${schemaName} = z.enum(${valuesName});\nexport type ${typeName} = z.infer<typeof ${schemaName}>;\nexport const ${enumName} = ${schemaName}.enum;`;
+		return `export const ${valuesName} = [\n\t${values.map((value) => `"${value}"`).join(',\n\t')},\n] as const;\nexport const ${schemaName} = z.enum(${valuesName});\nexport type ${typeName} = z.infer<typeof ${schemaName}>;\nexport const ${enumName} = ${schemaName}.enum;`
 	}
 
-  function stringifyRecord({ name, schema }: CollectionModel) {
+	function stringifyRecord({ name, fields }: CollectionModel) {
-    const schemaName = opts.nameRecordSchema(name);
+		const schemaName = opts.nameRecordSchema(name)
-    const typeName = opts.nameRecordType(name);
+		const typeName = opts.nameRecordType(name)
-    const fields = sortBy(schema, ["name"]).map((field) => stringifyField(field, name));
-    return `export const ${schemaName} = z.object({\n\t...RecordModel.omit({ expand: true }).shape,\n\tcollectionName: z.literal("${name}"),\n\t${fields.join(",\n\t")},\n});\nexport type ${typeName} = z.infer<typeof ${schemaName}>;`;
-  }
 
-  function stringifyField(field: SchemaField, collectionName: string) {
+		const systemFields = new Set([
-    let schema: string | undefined;
+			'id',
-    if (field.type === "bool") schema = stringifyBoolField(field);
+			'created',
-    else if (field.type === "date") schema = stringifyDateField(field);
+			'updated',
-    else if (field.type === "editor") schema = stringifyEditorField(field);
+			'collectionId',
-    else if (field.type === "email") schema = stringifyEmailField(field);
+			'collectionName',
-    else if (field.type === "file") schema = stringifyFileField(field);
+			'expand',
-    else if (field.type === "json") schema = stringifyJsonField(field);
+			'password',
-    else if (field.type === "number") schema = stringifyNumberField(field);
+			'tokenKey',
-    else if (field.type === "relation") schema = stringifyRelationField(field);
+		])
-    else if (field.type === "select") schema = stringifySelectField(field, collectionName);
-    else if (field.type === "text") schema = stringifyTextField(field);
-    else if (field.type === "url") schema = stringifyUrlField(field);
-    // TODO: manage unknown field type
-    return `${field.name}: ${schema}${field.required ? "" : ".optional()"}`;
-  }
 
-  function stringifyBoolField(_: SchemaField) {
+		const customFields = fields.filter((field) => !systemFields.has(field.name))
-    return "z.boolean()";
+		const fieldStrings = sortBy(customFields, ['name']).map((field) => stringifyField(field, name))
-  }
 
-  function stringifyDateField(_field: SchemaField) {
+		return `export const ${schemaName} = z.object({\n\t...RecordModel.omit({ expand: true }).shape,\n\tcollectionName: z.literal("${name}"),\n\t${fieldStrings.join(',\n\t')},\n});\nexport type ${typeName} = z.infer<typeof ${schemaName}>;`
-    // TODO: implement min and max
-    return "z.string().pipe(z.coerce.date())";
-  }
-
-  function stringifyEditorField(_field: SchemaField) {
-    // TODO: implement convertUrls
-    return "z.string()";
-  }
-
-  function stringifyEmailField(_field: SchemaField) {
-    // TODO: implement exceptDomains and onlyDomains
-    return "z.string().email()";
-  }
-
-  function stringifyFileField({ options: { maxSelect } }: SchemaField) {
-    // TODO: implement maxSize, mimeTypes, protected, thumbs
-    return `z.string()${maxSelect === 1 ? "" : `.array().max(${maxSelect})`}`;
-  }
-
-  function stringifyJsonField(_field: SchemaField) {
-    // TODO: implement maxSize and json schema
-    return "z.any()";
-  }
-
-  function stringifyNumberField({ options: { max, min, noDecimal } }: SchemaField) {
-    return `z.number()${noDecimal ? ".int()" : ""}${min ? `.min(${min})` : ""}${max ? `.max(${max})` : ""}`;
-  }
-
-  function stringifyRelationField({ options, required }: SchemaField) {
-    const { maxSelect, minSelect } = options;
-    // TODO: implement cascadeDelete, displayFields
-    const min = minSelect ? `.min(${minSelect})` : "";
-    const max = maxSelect ? `.max(${maxSelect})` : "";
-    const multiple = maxSelect === 1 ? "" : `.array()${min}${max}`;
-    const isOptional = required || maxSelect !== 1 ? `` : `.transform((id) => id === "" ? undefined : id)`;
-    return `z.string()${isOptional}${multiple}`;
-  }
-
-  function stringifySelectField({ name, options: { maxSelect } }: SchemaField, collectionName: string) {
-    // TODO: implement values
-    return `${opts.nameEnumSchema(opts.nameEnumField(collectionName, name))}${maxSelect === 1 ? "" : `.array().max(${maxSelect})`}`;
-  }
-
-  function stringifyTextField({ options: { max, min } }: SchemaField) {
-    // TODO: implement pattern
-    return `z.string()${min ? `.min(${min})` : ""}${max ? `.max(${max})` : ""}`;
-  }
-
-  function stringifyUrlField(_field: SchemaField) {
-    // TODO: implement exceptDomains and onlyDomains
-    return "z.string().url()";
 	}
 
 	function stringifySchemasEntry({ name }: CollectionModel) {
-    return `["${name}", ${opts.nameRecordSchema(name)}]`;
+		return `["${name}", ${opts.nameRecordSchema(name)}]`
 	}
 
 	function stringifyService({ name }: CollectionModel) {
-    return `\t\tcollection(idOrName: "${name}"): RecordService<z.input<typeof ${opts.nameRecordSchema(name)}>>;`;
+		return `\t\tcollection(idOrName: "${name}"): RecordService<z.input<typeof ${opts.nameRecordSchema(name)}>>;`
+	}
+
+	function stringifyField(field: CollectionField, collectionName: string) {
+		let schema: string
+		switch (field.type) {
+			case 'bool':
+				schema = 'z.boolean()'
+				break
+
+			case 'date':
+				const minConstraintDate = field.min ? `.min(new Date("${field.min}"))` : ''
+				const maxConstraintDate = field.max ? `.max(new Date("${field.max}"))` : ''
+
+				schema = `z.string().pipe(z.coerce.date()${minConstraintDate}${maxConstraintDate})`
+				break
+
+			case 'editor':
+				// TODO: implement convertUrls
+				schema = 'z.string()'
+				break
+
+			case 'email':
+				const onlyDomainsConstraint = createDomainConstraint(field.onlyDomains, true, 'email')
+				const exceptDomainsConstraint = createDomainConstraint(field.exceptDomains, false, 'email')
+
+				schema = `z.string().email()${onlyDomainsConstraint}${exceptDomainsConstraint}`
+				break
+
+			case 'file':
+				const maxSelectFile: number = field.maxSelect
+				const maxSizeFile: number = field.maxSize
+				const mimeTypesArray: string[] = field.mimeTypes || []
+				// const protectedFile: boolean = field.protected;
+				// const thumbsFileArray: string[] = field.thumbs || [];
+
+				const fileFieldMaxSelect = maxSelectFile ? `.max(${maxSelectFile})` : ''
+				const fileFieldTypeArray = maxSelectFile === 1 ? '' : `.array()${fileFieldMaxSelect}`
+
+				let fileValidation = 'z.instanceof(File)'
+
+				if (maxSizeFile)
+					fileValidation += `.refine((file) => file.size <= ${maxSizeFile}, { message: "File size too large" })`
+
+				if (mimeTypesArray.length > 0)
+					fileValidation += `.refine((file) => ${JSON.stringify(mimeTypesArray)}.includes(file.type), { message: "Invalid file type" })`
+
+				const baseFileSchema = `z.union([z.string(), ${fileValidation}])`
+				schema = `${baseFileSchema}${fileFieldTypeArray}`
+				break
+
+			case 'json':
+				schema = field.maxSize > 0 ? `pbJsonField(${field.maxSize})` : 'pbJsonField()'
+				break
+
+			case 'number':
+				const maxNumber = field.maxNumber ? `.max(${field.maxNumber})` : ''
+				const minNumber = field.minNumber ? `.min(${field.minNumber})` : ''
+				const noDecimal = field.noDecimal ? '.int()' : ''
+
+				schema = `z.number()${noDecimal}${minNumber}${maxNumber}`
+				break
+
+			case 'relation':
+				// TODO: implement cascadeDelete, displayFields, multiple records query
+				const multiple =
+					field.maxSelect === 1 ? '' : `.array().min(${field.minSelect}).max(${field.maxSelect})`
+				const isOptional =
+					field.required || field.maxSelect !== 1
+						? ``
+						: `.transform((id: string) => id === "" ? undefined : id)`
+
+				schema = `z.string()${isOptional}${multiple}`
+				break
+
+			case 'select':
+				const maxSelect = field.maxSelect === 1 ? '' : `.array().max(${field.maxSelect})`
+
+				schema = `${opts.nameEnumSchema(opts.nameEnumField(collectionName, field.name))}${maxSelect}`
+				break
+
+			case 'text':
+				const patternText =
+					field.pattern && field.pattern.trim() !== ''
+						? `.regex(new RegExp("${field.pattern.replace(/"/g, '\\"')}"))`
+						: ''
+				const maxText = field.max ? `.max(${field.max})` : ''
+				const minText = field.min ? `.min(${field.min})` : ''
+
+				schema = `z.string()${minText}${maxText}${patternText}`
+				break
+
+			case 'url':
+				const onlyDomainsUrlConstraint = createDomainConstraint(field.onlyDomains, true, 'url')
+				const exceptDomainsUrlConstraint = createDomainConstraint(field.exceptDomains, false, 'url')
+
+				schema = `z.string().url()${onlyDomainsUrlConstraint}${exceptDomainsUrlConstraint}`
+				break
+
+			case 'geoPoint':
+				schema =
+					'z.object({ lat: z.number().min(-90).max(90), lon: z.number().min(-180).max(180) })'
+				break
+
+			default:
+				console.warn(
+					`Unknown field type "${field.type}" for field "${field.name}". Using z.any() as fallback.`,
+				)
+				schema = 'z.any()'
+				break
+		}
+		return `${field.name}: ${schema}${(field as any).required ? '' : '.optional()'}`
+	}
+
+	/* Helpers */
+
+	const createDomainConstraint = (
+		domains: string[],
+		isWhitelist: boolean,
+		type: 'email' | 'url',
+	) => {
+		if (!domains?.length) return ''
+
+		const domainsList = domains.map((domain) => `"${domain}"`).join(', ')
+		const messageType = isWhitelist
+			? "isn't one of the allowed ones"
+			: 'is one of the disallowed ones'
+		const negation = isWhitelist ? '' : '!'
+
+		const domainExtraction =
+			type === 'email'
+				? 'const domain = value.split("@")[1];'
+				: 'const domain = new URL(value).hostname;'
+
+		const errorHandling = type === 'url' ? 'try { ' : ''
+		const errorCatch = type === 'url' ? ' } catch { return false; }' : ''
+
+		return `.refine((value: string) => { ${errorHandling}${domainExtraction} const domainsArray = [${domainsList}]; return domain && ${negation}domainsArray.includes(domain);${errorCatch} }, { message: "Invalid ${type}, domain ${messageType}" })`
 	}
 
 	return {
-    collectionNames: `[\n\t${collections.map(({ name }) => `"${name}"`).join(",\n\t")},\n]`,
+		collectionNames: `[\n\t${collections.map(({ name }) => `"${name}"`).join(',\n\t')},\n]`,
-    enums: getCollectionSelectFields().map(stringifyEnum).join("\n\n"),
+		enums: getCollectionSelectFields().map(stringifyEnum).join('\n\n'),
-    records: `${collections.map(stringifyRecord).join("\n\n")}\n\nexport const records = new Map<Collection, z.AnyZodObject>([\n\t${collections.map(stringifySchemasEntry).join(",\n\t")},\n]);`,
+		records: `${collections.map(stringifyRecord).join('\n\n')}\n\nexport const records = new Map<Collection, z.AnyZodObject>([\n\t${collections.map(stringifySchemasEntry).join(',\n\t')},\n]);`,
-    services: collections.map(stringifyService).join("\n"),
+		services: collections.map(stringifyService).join('\n'),
-  };
+	}
 }
 
-export type SelectField = { name: string; values: string[] };
+export type SelectField = { name: string; values: string[] }

src/helpers.ts

@@ -1,29 +1,50 @@
-import type { default as Pocketbase, SendOptions } from "pocketbase";
+import type { default as Pocketbase, SendOptions } from 'pocketbase'
-import { fullListOptionsFrom, optionsFrom } from "./options.js";
+import { fullListOptionsFrom, optionsFrom } from '@/options.ts'
-import type { AnyZodRecord, RecordFullListOpts, RecordIdRef, RecordRef, RecordSlugRef } from "./types.ts";
+import type { RecordsList } from '@/schemas.ts'
-import { AnyRecordsList, type RecordsList } from "./schemas.ts";
+import { AnyRecordsList } from '@/schemas.ts'
+import type {
+	AnyZodRecord,
+	RecordFullListOpts,
+	RecordIdRef,
+	RecordRef,
+	RecordSlugRef,
+} from '@/types.ts'
 
 export function helpersFrom({ fetch, pocketbase }: HelpersFromOpts) {
-  async function getRecord<C extends string, S extends AnyZodRecord>(ref: RecordSlugRef<C>, opts: GetRecordOpts<S>): Promise<S["_output"]>;
+	async function getRecord<C extends string, S extends AnyZodRecord>(
-  async function getRecord<C extends string, S extends AnyZodRecord>(ref: RecordIdRef<C>, opts: GetRecordOpts<S>): Promise<S["_output"]>;
+		ref: RecordSlugRef<C>,
-  async function getRecord<C extends string, S extends AnyZodRecord>(ref: RecordRef<C>, opts: GetRecordOpts<S>) {
+		opts: GetRecordOpts<S>,
-    const { schema } = opts;
+	): Promise<S['_output']>
-    const sdkOpts = { ...optionsFrom(schema), ...(fetch ? { fetch } : {}) };
+	async function getRecord<C extends string, S extends AnyZodRecord>(
-    const unsafeRecord = await ("id" in ref
+		ref: RecordIdRef<C>,
+		opts: GetRecordOpts<S>,
+	): Promise<S['_output']>
+	async function getRecord<C extends string, S extends AnyZodRecord>(
+		ref: RecordRef<C>,
+		opts: GetRecordOpts<S>,
+	) {
+		const { schema } = opts
+		const sdkOpts = { ...optionsFrom(schema), ...(fetch ? { fetch } : {}) }
+		const unsafeRecord = await ('id' in ref
 			? pocketbase.collection(ref.collection).getOne(ref.id, sdkOpts)
-      : pocketbase.collection(ref.collection).getFirstListItem(`slug = "${ref.slug}"`, sdkOpts));
+			: pocketbase.collection(ref.collection).getFirstListItem(`slug = "${ref.slug}"`, sdkOpts))
-    return schema.parseAsync(unsafeRecord);
+		return schema.parseAsync(unsafeRecord)
 	}
 
-  async function getRecords<C extends string, S extends AnyZodRecord>(collection: C, opts: GetRecordsOpts<S>): Promise<RecordsList<S>> {
+	async function getRecords<C extends string, S extends AnyZodRecord>(
-    const { schema, ...otherOpts } = opts;
+		collection: C,
-    const sdkOpts = { ...fullListOptionsFrom(schema, otherOpts), ...(fetch ? { fetch } : {}) };
+		opts: GetRecordsOpts<S>,
-    const recordsList = await pocketbase.collection(collection).getList(sdkOpts.page, sdkOpts.perPage, sdkOpts);
+	): Promise<RecordsList<S>> {
-    return AnyRecordsList.extend({ items: schema.array() }).parseAsync(recordsList);
+		const { schema, ...otherOpts } = opts
+		const sdkOpts = { ...fullListOptionsFrom(schema, otherOpts), ...(fetch ? { fetch } : {}) }
+		const recordsList = await pocketbase
+			.collection(collection)
+			.getList(sdkOpts.page, sdkOpts.perPage, sdkOpts)
+		return AnyRecordsList.extend({ items: schema.array() }).parseAsync(recordsList)
 	}
 
-  return { getRecord, getRecords };
+	return { getRecord, getRecords }
 }
-export type GetRecordOpts<S extends AnyZodRecord> = { schema: S };
+export type GetRecordOpts<S extends AnyZodRecord> = { schema: S }
-export type GetRecordsOpts<S extends AnyZodRecord> = RecordFullListOpts<S> & { schema: S };
+export type GetRecordsOpts<S extends AnyZodRecord> = RecordFullListOpts<S> & { schema: S }
-export type HelpersFromOpts = { fetch?: SendOptions["fetch"]; pocketbase: Pocketbase };
+export type HelpersFromOpts = { fetch?: SendOptions['fetch']; pocketbase: Pocketbase }

src/index.ts

@@ -1,6 +1,6 @@
-export * from "./config.js";
+export * from './config.js'
-export * from "./helpers.js";
+export * from './helpers.js'
-export * from "./options.js";
+export * from './options.js'
-export * from "./schemas.js";
+export * from './schemas.js'
-export * from "./types.ts";
+export * from './types.ts'
-export * from "./utils.js";
+export * from './utils.js'

src/options.ts

@@ -1,5 +1,6 @@
-import { z, type AnyZodObject, type ZodTypeAny } from "zod";
+import type { AnyZodObject, ZodTypeAny } from 'zod'
-import type { AnyZodRecord, RecordFullListOpts, RecordListOpts } from "./types.ts";
+import { z } from 'zod'
+import type { AnyZodRecord, RecordFullListOpts, RecordListOpts } from '@/types.ts'
 
 /**
  * Extends the given schema with the given expansion.
@@ -10,7 +11,7 @@ import type { AnyZodRecord, RecordFullListOpts, RecordListOpts } from "./types.t
 export function expandFrom<S extends AnyZodRecord>(schema: S) {
 	return expandFromRec(schema)
 		.sort((k1, k2) => (k1 < k2 ? -1 : 1))
-    .join(",");
+		.join(',')
 }
 
 /**
@@ -22,7 +23,7 @@ export function expandFrom<S extends AnyZodRecord>(schema: S) {
 export function fieldsFrom<S extends AnyZodRecord>(schema: S) {
 	return fieldsFromRec(schema)
 		.sort((k1, k2) => (k1 < k2 ? -1 : 1))
-    .join(",");
+		.join(',')
 }
 
 /**
@@ -32,7 +33,7 @@ export function fieldsFrom<S extends AnyZodRecord>(schema: S) {
  * @returns A new schema extended with the given expansion
  */
 export function optionsFrom<S extends AnyZodRecord>(schema: S) {
-  return { expand: expandFrom(schema), fields: fieldsFrom(schema) };
+	return { expand: expandFrom(schema), fields: fieldsFrom(schema) }
 }
 
 /**
@@ -42,8 +43,8 @@ export function optionsFrom<S extends AnyZodRecord>(schema: S) {
  * @returns A new schema extended with the given expansion
  */
 export function listOptionsFrom<S extends AnyZodRecord>(schema: S, opts: RecordListOpts<S>) {
-  const { page = 1, perPage = 30, ...rest } = opts;
+	const { page = 1, perPage = 30, ...rest } = opts
-  return { ...optionsFrom(schema), page, perPage, ...rest };
+	return { ...optionsFrom(schema), page, perPage, ...rest }
 }
 
 /**
@@ -52,46 +53,55 @@ export function listOptionsFrom<S extends AnyZodRecord>(schema: S, opts: RecordL
  * @param shape - The shape of the expansion
  * @returns A new schema extended with the given expansion
  */
-export function fullListOptionsFrom<S extends AnyZodRecord>(schema: S, opts: RecordFullListOpts<S>) {
+export function fullListOptionsFrom<S extends AnyZodRecord>(
-  const { page = 1, perPage = 200, skipTotal = true, ...rest } = opts;
+	schema: S,
-  return listOptionsFrom(schema, { page, perPage, skipTotal, ...rest });
+	opts: RecordFullListOpts<S>,
+) {
+	const { page = 1, perPage = 200, skipTotal = true, ...rest } = opts
+	return listOptionsFrom(schema, { page, perPage, skipTotal, ...rest })
 }
 
-function expandFromRec<S extends ZodTypeAny>(schema: S, prefix = "") {
+function expandFromRec<S extends ZodTypeAny>(schema: S, prefix = '') {
-  let expands: string[] = [];
+	let expands: string[] = []
-  const shape = getObjectSchemaDescendant(schema)?.shape;
+	const shape = getObjectSchemaDescendant(schema)?.shape
-  if (!shape || !("expand" in shape)) return [];
+	if (!shape || !('expand' in shape)) return []
 	for (const [key, value] of Object.entries(getObjectSchemaDescendant(shape.expand)!.shape)) {
-    expands = [...expands, `${prefix}${key}`];
+		expands = [...expands, `${prefix}${key}`]
-    if (hasObjectSchemaDescendant(value)) expands = [...expands, ...expandFromRec(getObjectSchemaDescendant(value)!, `${prefix}${key}.`)];
+		if (hasObjectSchemaDescendant(value))
+			expands = [
+				...expands,
+				...expandFromRec(getObjectSchemaDescendant(value)!, `${prefix}${key}.`),
+			]
 	}
-  return expands;
+	return expands
 }
 
-function fieldsFromRec<S extends z.ZodTypeAny>(schema: S, prefix = "") {
+function fieldsFromRec<S extends z.ZodTypeAny>(schema: S, prefix = '') {
-  let fields: string[] = [];
+	let fields: string[] = []
-  const shape = getObjectSchemaDescendant(schema)?.shape;
+	const shape = getObjectSchemaDescendant(schema)?.shape
-  if (!shape) return [];
+	if (!shape) return []
 	for (const [key, value] of Object.entries(shape)) {
 		fields = [
 			...fields,
-      ...(hasObjectSchemaDescendant(value) ? fieldsFromRec(getObjectSchemaDescendant(value)!, `${prefix}${key}.`) : [`${prefix}${key}`]),
+			...(hasObjectSchemaDescendant(value)
-    ];
+				? fieldsFromRec(getObjectSchemaDescendant(value)!, `${prefix}${key}.`)
+				: [`${prefix}${key}`]),
+		]
 	}
-  return fields.sort((k1, k2) => (k1 < k2 ? -1 : 1));
+	return fields.sort((k1, k2) => (k1 < k2 ? -1 : 1))
 }
 
 function hasObjectSchemaDescendant(value: unknown): value is z.ZodTypeAny {
-  if (value instanceof z.ZodEffects) return hasObjectSchemaDescendant(value.innerType());
+	if (value instanceof z.ZodEffects) return hasObjectSchemaDescendant(value.innerType())
-  if (value instanceof z.ZodArray) return hasObjectSchemaDescendant(value.element);
+	if (value instanceof z.ZodArray) return hasObjectSchemaDescendant(value.element)
-  if (value instanceof z.ZodOptional) return hasObjectSchemaDescendant(value.unwrap());
+	if (value instanceof z.ZodOptional) return hasObjectSchemaDescendant(value.unwrap())
-  return value instanceof z.ZodObject;
+	return value instanceof z.ZodObject
 }
 
 function getObjectSchemaDescendant<S extends z.ZodTypeAny>(schema: S): AnyZodObject | undefined {
-  if (schema instanceof z.ZodEffects) return getObjectSchemaDescendant(schema.innerType());
+	if (schema instanceof z.ZodEffects) return getObjectSchemaDescendant(schema.innerType())
-  if (schema instanceof z.ZodArray) return getObjectSchemaDescendant(schema.element);
+	if (schema instanceof z.ZodArray) return getObjectSchemaDescendant(schema.element)
-  if (schema instanceof z.ZodOptional) return getObjectSchemaDescendant(schema.unwrap());
+	if (schema instanceof z.ZodOptional) return getObjectSchemaDescendant(schema.unwrap())
-  if (schema instanceof z.ZodObject) return schema;
+	if (schema instanceof z.ZodObject) return schema
-  return;
+	return
 }

src/schemas.ts

@@ -1,5 +1,6 @@
-import { type AnyZodObject, type objectUtil, z, type ZodEffects, type ZodObject, ZodOptional, type ZodRawShape } from "zod";
+import type { AnyZodObject, objectUtil, ZodObject, ZodRawShape } from 'zod'
-import type { AnyZodRecord, HasRequiredKeys, ZodRecordKeys } from "./types.ts";
+import { ZodEffects, ZodOptional, z } from 'zod'
+import type { AnyZodRecord, HasRequiredKeys, ZodRecordKeys } from '@/types.ts'
 
 /**
  * Records list schema.
@@ -10,7 +11,7 @@ export const AnyRecordsList = z.object({
 	perPage: z.number().int().min(1),
 	totalItems: z.number().int().min(-1),
 	totalPages: z.number().int().min(-1),
-});
+})
 
 /**
  * Extends the given schema with the given expansion.
@@ -19,10 +20,15 @@ export const AnyRecordsList = z.object({
  * @returns A new schema extended with the given expansion
  */
 export function expand<S extends AnyZodObject, E extends ZodRawShape>(schema: S, shape: E) {
-  const isExpandOptional = Object.entries(shape).every(([, value]) => value instanceof z.ZodOptional);
+	const isExpandOptional = Object.entries(shape).every(
+		([, value]) => value instanceof z.ZodOptional,
+	)
 	return z
-    .object({ ...schema.shape, expand: isExpandOptional ? z.object(shape).optional() : z.object(shape) })
+		.object({
-    .transform(({ expand, ...rest }) => ({ ...rest, ...(expand ?? {}) })) as ZodObjectExpand<S, E>;
+			...schema.shape,
+			expand: isExpandOptional ? z.object(shape).optional() : z.object(shape),
+		})
+		.transform(({ expand, ...rest }) => ({ ...rest, ...(expand ?? {}) })) as ZodObjectExpand<S, E>
 }
 
 /**
@@ -32,7 +38,7 @@ export function expand<S extends AnyZodObject, E extends ZodRawShape>(schema: S,
  * @returns A new schema with only the given keys
  */
 export function pick<S extends AnyZodObject, K extends ZodRecordKeys<S>[]>(schema: S, keys: K) {
-  return schema.pick(Object.fromEntries(keys.map((key) => [key, true]))) as ZodObjectPick<S, K>;
+	return schema.pick(Object.fromEntries(keys.map((key) => [key, true]))) as ZodObjectPick<S, K>
 }
 
 /**
@@ -46,26 +52,43 @@ export function select<S extends AnyZodObject, K extends ZodRecordKeys<S>[], E e
 	schema: S,
 	keys: K,
 	shape: E,
-): ZodObjectExpand<ZodObjectPick<S, K>, E>;
+): ZodObjectExpand<ZodObjectPick<S, K>, E>
-export function select<S extends AnyZodObject, K extends ZodRecordKeys<S>[]>(schema: S, keys: K): ZodObjectPick<S, K>;
+export function select<S extends AnyZodObject, K extends ZodRecordKeys<S>[]>(
-export function select<S extends AnyZodObject, K extends ZodRecordKeys<S>[], E extends ZodRawShape | undefined>(
 	schema: S,
 	keys: K,
-  shape?: E,
+): ZodObjectPick<S, K>
-) {
+export function select<
-  return shape ? expand(pick(schema, keys), shape) : pick(schema, keys);
+	S extends AnyZodObject,
+	K extends ZodRecordKeys<S>[],
+	E extends ZodRawShape | undefined,
+>(schema: S, keys: K, shape?: E) {
+	return shape ? expand(pick(schema, keys), shape) : pick(schema, keys)
 }
 
-export type ZodObjectExpand<S extends AnyZodObject, E extends ZodRawShape> =
+export type ZodObjectExpand<S extends AnyZodObject, E extends ZodRawShape> = S extends ZodObject<
-  S extends ZodObject<infer T, infer U, infer C>
+	infer T,
-    ? ZodEffects<
+	infer U,
-        ZodObject<objectUtil.extendShape<T, { expand: HasRequiredKeys<E> extends true ? ZodObject<E> : ZodOptional<ZodObject<E>> }>, U, C>,
+	infer C
-        ZodObject<objectUtil.extendShape<T, E>, U, C>["_output"]
 >
-    : never;
+	? ZodEffects<
+			ZodObject<
+				objectUtil.extendShape<
+					T,
+					{ expand: HasRequiredKeys<E> extends true ? ZodObject<E> : ZodOptional<ZodObject<E>> }
+				>,
+				U,
+				C
+			>,
+			ZodObject<objectUtil.extendShape<T, E>, U, C>['_output']
+		>
+	: never
 
-export type ZodObjectPick<S extends AnyZodObject, K extends ZodRecordKeys<S>[]> =
+export type ZodObjectPick<
-  S extends ZodObject<infer T, infer U, infer C> ? ZodObject<Pick<T, K[number]>, U, C> : never;
+	S extends AnyZodObject,
+	K extends ZodRecordKeys<S>[],
+> = S extends ZodObject<infer T, infer U, infer C> ? ZodObject<Pick<T, K[number]>, U, C> : never
 
-export type AnyRecordsList = z.infer<typeof AnyRecordsList>;
+export type AnyRecordsList = z.infer<typeof AnyRecordsList>
-export type RecordsList<S extends AnyZodRecord> = Omit<AnyRecordsList, "items"> & { items: S["_output"][] };
+export type RecordsList<S extends AnyZodRecord> = Omit<AnyRecordsList, 'items'> & {
+	items: S['_output'][]
+}

src/sdk.ts

@@ -1,13 +1,13 @@
-import Pocketbase from "pocketbase";
+import Pocketbase from 'pocketbase'
-import type { Credentials } from "./config.ts";
+import type { Credentials } from '@/config.ts'
 
-let adminPocketbase: Pocketbase;
+let adminPocketbase: Pocketbase
 
 export async function getPocketbase({ adminEmail, adminPassword, url }: Credentials) {
 	if (!adminPocketbase) {
-    const pocketbase = new Pocketbase(url);
+		const pocketbase = new Pocketbase(url)
-    await pocketbase.collection("_superusers").authWithPassword(adminEmail, adminPassword);
+		await pocketbase.collection('_superusers').authWithPassword(adminEmail, adminPassword)
-    adminPocketbase = pocketbase;
+		adminPocketbase = pocketbase
 	}
-  return adminPocketbase;
+	return adminPocketbase
 }

src/server/cli.ts

@@ -1,91 +1,125 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
-import { Config, type ResolvedConfig } from "../config.ts";
+import { existsSync } from 'node:fs'
-import pkg from "../../package.json" with { type: "json" };
+import {
-import { loadConfig } from "c12";
+	cancel,
-import { defineCommand, runMain } from "citty";
+	confirm,
-import { cancel, group, intro, log, outro, confirm, text, spinner, multiselect, isCancel } from "@clack/prompts";
+	group,
-import { fetchCollections } from "../utils.ts";
+	intro,
-import { generate } from "./utils.ts";
+	isCancel,
-import { existsSync } from "node:fs";
+	log,
+	multiselect,
+	outro,
+	spinner,
+	text,
+} from '@clack/prompts'
+import { loadConfig } from 'c12'
+import { defineCommand, runMain } from 'citty'
+import type { ResolvedConfig } from '@/config.ts'
+import { Config } from '@/config.ts'
+import { generate } from '@/server/utils.ts'
+import { fetchCollections } from '@/utils.ts'
+import pkg from '../../package.json' with { type: 'json' }
 
 async function getConfig() {
-  const { config } = await loadConfig({ name: "zod-pocketbase", rcFile: false, dotenv: true });
+	const { config } = await loadConfig({
-  const { ZOD_POCKETBASE_ADMIN_EMAIL: adminEmail, ZOD_POCKETBASE_ADMIN_PASSWORD: adminPassword, ZOD_POCKETBASE_URL: url } = process.env;
+		name: 'zod-pocketbase-continue',
-  const result = Config.safeParse({ ...config, adminEmail, adminPassword, url });
+		rcFile: false,
+		dotenv: true,
+	})
+	const {
+		ZOD_POCKETBASE_ADMIN_EMAIL: adminEmail,
+		ZOD_POCKETBASE_ADMIN_PASSWORD: adminPassword,
+		ZOD_POCKETBASE_URL: url,
+	} = process.env
+	const result = Config.safeParse({ ...config, adminEmail, adminPassword, url })
 	if (!result.success) {
-    log.error("Invalid fields in your config file.");
+		log.error('Invalid fields in your config file.')
-    onCancel();
+		onCancel()
 	}
-  return result.data!;
+	return result.data!
 }
 
 function onCancel() {
-  cancel("Operation cancelled.");
+	cancel('Operation cancelled.')
-  process.exit(0);
+	process.exit(0)
 }
 
 async function selectCollections(config: ResolvedConfig) {
 	const credentialPrompts = {
-    url: () => text({ message: "What is the url of your pocketbase instance?", initialValue: config.url ?? "" }),
+		url: () =>
-    adminEmail: () => text({ message: "What is your admin's email?", initialValue: config.adminEmail ?? "" }),
+			text({
-    adminPassword: () => text({ message: "What is your admin's password?", initialValue: config.adminPassword ?? "" }),
+				message: 'What is the url of your pocketbase instance?',
-  };
+				initialValue: config.url ?? '',
-  const credentials = await group(credentialPrompts, { onCancel });
+			}),
-  const s = spinner();
+		adminEmail: () =>
-  s.start("Fetching collections...");
+			text({ message: "What is your admin's email?", initialValue: config.adminEmail ?? '' }),
+		adminPassword: () =>
+			text({ message: "What is your admin's password?", initialValue: config.adminPassword ?? '' }),
+	}
+	const credentials = await group(credentialPrompts, { onCancel })
+	const s = spinner()
+	s.start('Fetching collections...')
 	try {
-    const allCollections = await fetchCollections(credentials);
+		const allCollections = await fetchCollections(credentials)
-    s.stop("Successfully fetched collections.");
+		s.stop('Successfully fetched collections.')
 		const collectionNames = await multiselect({
-      message: "What collections do you want to generate schemas for?",
+			message: 'What collections do you want to generate schemas for?',
 			options: allCollections.map(({ name: value }) => ({ value })),
-      initialValues: allCollections.filter(({ name }) => !config.ignore.includes(name)).map(({ name }) => name),
+			initialValues: allCollections
-    });
+				.filter(({ name }) => !config.ignore.includes(name))
-    if (isCancel(collectionNames)) onCancel();
+				.map(({ name }) => name),
-    return allCollections.filter(({ name }) => (collectionNames as string[]).includes(name));
+		})
+		if (isCancel(collectionNames)) onCancel()
+		return allCollections.filter(({ name }) => (collectionNames as string[]).includes(name))
 	} catch {
-    s.stop("Failed to fetch collections.Please check your credentials and try again.");
+		s.stop('Failed to fetch collections.Please check your credentials and try again.')
-    return selectCollections(config);
+		return selectCollections(config)
 	}
 }
 
 async function setGeneratedFilePath(config: ResolvedConfig) {
 	const output = await text({
-    message: "What is the generated file path?",
+		message: 'What is the generated file path?',
 		initialValue: config.output,
 		validate: (value) => {
-      if (!value) return "Please enter a path.";
+			if (!value) return 'Please enter a path.'
-      if (value[0] !== ".") return "Please enter a relative path.";
+			if (value[0] !== '.') return 'Please enter a relative path.'
-      return;
+			return
 		},
-  });
+	})
-  if (isCancel(output)) onCancel();
+	if (isCancel(output)) onCancel()
 
 	if (existsSync(output as string)) {
-    const confirmed = await confirm({ message: "The file already exists, would you like to overwrite it?" });
+		const confirmed = await confirm({
-    if (isCancel(confirmed)) onCancel();
+			message: 'The file already exists, would you like to overwrite it?',
-    if (!confirmed) return setGeneratedFilePath(config);
+		})
+		if (isCancel(confirmed)) onCancel()
+		if (!confirmed) return setGeneratedFilePath(config)
 	}
 
-  return output as string;
+	return output as string
 }
 
 const main = defineCommand({
-  meta: { name: "zod-pocketbase", version: pkg.version, description: "Generate Zod schemas for your pocketbase instance." },
+	meta: {
-  run: async () => {
+		name: 'zod-pocketbase-continue',
-    intro(`ZOD POCKETBASE`);
+		version: pkg.version,
-    const config = await getConfig();
+		description: 'Generate Zod schemas for your pocketbase instance.',
-    const collections = await selectCollections(config);
-    const output = await setGeneratedFilePath(config);
-
-    const s = spinner();
-    s.start("Generating your schemas...");
-    await generate(collections, { ...config, output });
-    s.stop("Schemas successfully generated.");
-
-    outro("Operation completed.");
 	},
-});
+	run: async () => {
+		intro(`ZOD POCKETBASE`)
+		const config = await getConfig()
+		const collections = await selectCollections(config)
+		const output = await setGeneratedFilePath(config)
 
-runMain(main);
+		const s = spinner()
+		s.start('Generating your schemas...')
+		await generate(collections, { ...config, output })
+		s.stop('Schemas successfully generated.')
+
+		outro('Operation completed.')
+	},
+})
+
+runMain(main)

src/server/index.ts

@@ -1 +1 @@
-export * from "./utils.js";
+export * from './utils.js'

src/server/utils.ts

@@ -1,19 +1,22 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, resolve } from "node:path";
+import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from "node:url";
+import { fileURLToPath } from 'node:url'
-import type { CollectionModel } from "pocketbase";
+import type { CollectionModel } from 'pocketbase'
-import { stringifyContent } from "../content.js";
+import type { ResolvedConfig } from '@/config.ts'
-import type { ResolvedConfig } from "../config.ts";
+import { stringifyContent } from '@/content.js'
 
 export async function generate(collections: CollectionModel[], opts: GenerateOpts) {
-  const stub = readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../../assets/stubs/index.ts"), "utf-8");
+	const stub = readFileSync(
-  const { collectionNames, enums, records, services } = stringifyContent(collections, opts);
+		resolve(dirname(fileURLToPath(import.meta.url)), '../../assets/stubs/index.ts'),
+		'utf-8',
+	)
+	const { collectionNames, enums, records, services } = stringifyContent(collections, opts)
 	const content = stub
-    .replace("@@_COLLECTION_NAMES_@@", collectionNames)
+		.replace('@@_COLLECTION_NAMES_@@', collectionNames)
-    .replace("@@_ENUMS_@@", enums)
+		.replace('@@_ENUMS_@@', enums)
-    .replace("@@_RECORDS_@@", records)
+		.replace('@@_RECORDS_@@', records)
-    .replace("@@_SERVICES_@@", services);
+		.replace('@@_SERVICES_@@', services)
-  mkdirSync(dirname(opts.output), { recursive: true });
+	mkdirSync(dirname(opts.output), { recursive: true })
-  writeFileSync(opts.output, content);
+	writeFileSync(opts.output, content)
 }
-export type GenerateOpts = Omit<ResolvedConfig, "adminEmail" | "adminPassword" | "ignore" | "url">;
+export type GenerateOpts = Omit<ResolvedConfig, 'adminEmail' | 'adminPassword' | 'ignore' | 'url'>

src/types.ts

@@ -1,31 +1,33 @@
-import type { AnyZodObject, ZodEffects, ZodOptional, ZodRawShape, ZodTypeAny } from "zod";
+import type { AnyZodObject, ZodEffects, ZodOptional, ZodRawShape, ZodTypeAny } from 'zod'
 
-export type AnyZodRecord = AnyZodObject | ZodEffects<AnyZodObject>;
+export type AnyZodRecord = AnyZodObject | ZodEffects<AnyZodObject>
 
-export type RecordFullListOpts<S extends AnyZodRecord> = RecordListOpts<S> & { batch?: number };
+export type RecordFullListOpts<S extends AnyZodRecord> = RecordListOpts<S> & { batch?: number }
 
 export type RecordListOpts<S extends AnyZodRecord> = {
-  filter?: string;
+	filter?: string
-  page?: number;
+	page?: number
-  perPage?: number;
+	perPage?: number
-  skipTotal?: boolean;
+	skipTotal?: boolean
-  sort?: ZodRecordSort<S>;
+	sort?: ZodRecordSort<S>
-};
+}
 
-export type RecordIdRef<C extends string> = { collection: C; id: string };
+export type RecordIdRef<C extends string> = { collection: C; id: string }
-export type RecordSlugRef<C extends string> = { collection: C; slug: string };
+export type RecordSlugRef<C extends string> = { collection: C; slug: string }
-export type RecordRef<C extends string> = RecordIdRef<C> | RecordSlugRef<C>;
+export type RecordRef<C extends string> = RecordIdRef<C> | RecordSlugRef<C>
 
-export type ZodRecordKeys<S extends AnyZodRecord> = Extract<keyof S["_input"], string>;
+export type ZodRecordKeys<S extends AnyZodRecord> = Extract<keyof S['_input'], string>
 
-export type ZodRecordMainKeys<S extends AnyZodRecord> = Exclude<ZodRecordKeys<S>, "expand">;
+export type ZodRecordMainKeys<S extends AnyZodRecord> = Exclude<ZodRecordKeys<S>, 'expand'>
 
-export type ZodRecordSort<S extends AnyZodRecord> = `${"+" | "-"}${ZodRecordMainKeys<S>}` | "@random";
+export type ZodRecordSort<S extends AnyZodRecord> =
+	| `${'+' | '-'}${ZodRecordMainKeys<S>}`
+	| '@random'
 
 type RequiredKeysOf<S extends ZodRawShape> = Exclude<
 	{
-    [Key in keyof S]: S[Key] extends ZodOptional<ZodTypeAny> ? never : Key;
+		[Key in keyof S]: S[Key] extends ZodOptional<ZodTypeAny> ? never : Key
 	}[keyof S],
 	undefined
->;
+>
-export type HasRequiredKeys<S extends ZodRawShape> = RequiredKeysOf<S> extends never ? false : true;
+export type HasRequiredKeys<S extends ZodRawShape> = RequiredKeysOf<S> extends never ? false : true

src/utils.ts

@@ -1,10 +1,10 @@
-import { sortBy } from "es-toolkit";
+import { sortBy } from 'es-toolkit'
-import type { CollectionModel } from "pocketbase";
+import type { CollectionModel } from 'pocketbase'
-import { getPocketbase } from "./sdk.js";
+import type { Credentials } from '@/config.ts'
-import type { Credentials } from "./config.ts";
+import { getPocketbase } from '@/sdk.js'
 
 export async function fetchCollections(credentials: Credentials): Promise<CollectionModel[]> {
-  const pocketbase = await getPocketbase(credentials);
+	const pocketbase = await getPocketbase(credentials)
-  const collections = await pocketbase.collections.getFullList();
+	const collections = await pocketbase.collections.getFullList()
-  return sortBy(collections, ["name"]);
+	return sortBy(collections, ['name'])
 }

tsconfig.json

@@ -5,7 +5,7 @@
 		"target": "ESNext",
 		"module": "NodeNext",
 		// Enable module resolution without file extensions on relative paths, for things like npm package imports.
-    "moduleResolution": "Node16",
+		"moduleResolution": "nodenext",
 		// Allow importing TypeScript files using their native extension (.ts(x)).
 		"allowImportingTsExtensions": true,
 		// Enable JSON imports.
@@ -46,7 +46,11 @@
 		// Report an error for unreachable code instead of just a warning.
 		"allowUnreachableCode": false,
 		// Report an error for unused labels instead of just a warning.
-    "allowUnusedLabels": false
+		"allowUnusedLabels": false,
-  },
+		"baseUrl": ".",
-  "exclude": ["dist"]
+		"paths": {
+			"@/*": ["./src/*"]
+		}
+	},
+	"exclude": ["dist", "assets/stubs"]
 }

tsdown.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from 'tsdown'
+import packageJson from './package.json' with { type: 'json' }
+
+export default defineConfig((options) => {
+	const dev = !!options.watch
+	return {
+		entry: ['src/**/*.(ts|js)'],
+		format: ['esm'],
+		target: 'node24',
+		unbundle: true,
+		dts: true,
+		sourcemap: true,
+		clean: true,
+		splitting: false,
+		minify: !dev,
+		external: [...Object.keys(packageJson.peerDependencies), 'dotenv'],
+		tsconfig: 'tsconfig.json',
+	}
+})

tsup.config.ts

@@ -1,19 +0,0 @@
-import { defineConfig } from "tsup";
-import { peerDependencies } from "./package.json";
-
-export default defineConfig((options) => {
-  const dev = !!options.watch;
-  return {
-    entry: ["src/**/*.(ts|js)"],
-    format: ["esm"],
-    target: "node24",
-    bundle: true,
-    dts: true,
-    sourcemap: true,
-    clean: true,
-    splitting: false,
-    minify: !dev,
-    external: [...Object.keys(peerDependencies), "dotenv"],
-    tsconfig: "tsconfig.json",
-  };
-});