@antislop/zero-lucid-generator 1.0.0 → 1.1.1

package/README.md

@@ -26,13 +26,13 @@ npm add -D @antislop/zero-lucid-generator
 
 ### 1. Create a config file
 
-Create `lucid-zero.config.ts` at the root of your project:
+Create `config/lucid_zero.ts`:
 
 ```ts
 import type { Config } from '@antislop/zero-lucid-generator'
 
 const config: Config = {
-  modelsSourcePath: './app/models',
+  modelsDirectory: './app/models', // Optional; this is the default
 }
 
 export default config
@@ -44,7 +44,7 @@ export default config
 npx lucid-zero generate
 ```
 
-This writes `zero-schema.gen.ts` next to your config file.
+Run this from your project root. This writes `zero-schema.gen.ts` in the current working directory.
 
 ### 3. Import the schema
 
@@ -56,13 +56,12 @@ import { schema, zql } from './zero-schema.gen.js'
 
 ## Config options
 
-| Option | Type | Default | Description |
-|---|---|---|---|
-| `modelsSourcePath` | `string` | **required** | Path to your models directory, relative to the config file |
-| `output` | `string` | `zero-schema.gen.ts` | Output file path, relative to the config file |
-| `prettier` | `boolean` | `false` | Format the output with Prettier (must be installed) |
-| `excludeModels` | `LucidModel[]` | `[]` | Models to exclude from the generated schema |
-| `columnTypes` | `Record<string, Record<string, string>>` | `{}` | Override the inferred Zero type for specific columns |
+| Option                | Type                                     | Default              | Description                                                              |
+| --------------------- | ---------------------------------------- | -------------------- | ------------------------------------------------------------------------ |
+| `modelsDirectory`     | `string`                                 | `./app/models`       | Path to your models directory, relative to the current working directory |
+| `outputPath`          | `string`                                 | `zero-schema.gen.ts` | Output file path, relative to the current working directory              |
+| `excludeModels`       | `LucidModel[]`                           | `[]`                 | Models to exclude from the generated schema                              |
+| `columnTypeOverrides` | `Record<string, Record<string, string>>` | `{}`                 | Override the inferred Zero type for specific columns                     |
 
 ---
 
@@ -72,8 +71,8 @@ import { schema, zql } from './zero-schema.gen.js'
 lucid-zero generate [options]
 
 Options:
-  -c, --config <path>     Path to config file     (default: lucid-zero.config.ts)
-  -t, --tsconfig <path>   Path to tsconfig.json   (default: tsconfig.json next to config)
+  -c, --config <path>     Path to config file     (default: config/lucid_zero.ts)
+  -t, --tsconfig <path>   Path to tsconfig.json   (default: tsconfig.json in cwd)
 ```
 
 ---
@@ -82,24 +81,24 @@ Options:
 
 `@antislop/zero-lucid-generator` maps TypeScript types to Zero types automatically:
 
-| TypeScript type | Zero type |
-|---|---|
-| `string` | `string()` |
-| `number` | `number()` |
-| `boolean` | `boolean()` |
-| `DateTime` / `Date` | `number()` (Unix ms) |
-| `object` / `unknown` / `any` | `json()` |
-| `T \| null` or `T \| undefined` | `.optional()` |
+| TypeScript type                 | Zero type            |
+| ------------------------------- | -------------------- |
+| `string`                        | `string()`           |
+| `number`                        | `number()`           |
+| `boolean`                       | `boolean()`          |
+| `DateTime` / `Date`             | `number()` (Unix ms) |
+| `object` / `unknown` / `any`    | `json()`             |
+| `T \| null` or `T \| undefined` | `.optional()`        |
 
-When inference isn't accurate — for example a JSON column with a known shape — use `columnTypes`:
+When inference isn't accurate — for example a JSON column with a known shape — use `columnTypeOverrides`:
 
 ```ts
 import type { Config } from '@antislop/zero-lucid-generator'
-import Session from "#models/session";
+import Session from '#models/session'
 
 const config: Config = {
-  modelsSourcePath: './app/models',
-  columnTypes: {
+  modelsDirectory: './app/models',
+  columnTypeOverrides: {
     Issue: {
       // metadata is typed as `unknown` but has a known shape
       metadata: 'json<{ priority: number; labels: string[] }>()',
@@ -124,61 +123,54 @@ Valid Zero base types: `string`, `number`, `boolean`, `json`, `enumeration`.
 ```ts
 // zero-schema.gen.ts (auto-generated — do not edit)
 
-import {
-  createBuilder,
-  createSchema,
-  number,
-  relationships,
-  string,
-  table,
-} from "@rocicorp/zero";
+import { createBuilder, createSchema, number, relationships, string, table } from '@rocicorp/zero'
 
-export const users = table("users")
+export const users = table('users')
   .columns({
     id: number(),
     name: string(),
     email: string(),
   })
-  .primaryKey("id");
+  .primaryKey('id')
 
-export const posts = table("posts")
+export const posts = table('posts')
   .columns({
     id: number(),
     userId: number().from('user_id'),
     title: string(),
     body: string().optional(),
   })
-  .primaryKey("id");
+  .primaryKey('id')
 
 export const usersRelationships = relationships(users, ({ many }) => ({
   posts: many({
-    sourceField: ["id"],
-    destField: ["userId"],
+    sourceField: ['id'],
+    destField: ['userId'],
     destSchema: posts,
   }),
-}));
+}))
 
 export const schema = createSchema({
   tables: [users, posts],
   relationships: [usersRelationships],
-});
+})
 
-export type Schema = typeof schema;
+export type Schema = typeof schema
 
-export const zql = createBuilder(schema);
+export const zql = createBuilder(schema)
 ```
 
 ## Supported relation types
 
-| Lucid relation | Zero mapping |
-|---|---|
-| `hasOne` | `one(...)` |
-| `hasMany` | `many(...)` |
-| `belongsTo` | `one(...)` |
-| `manyToMany` | `many([...chain])` via pivot table |
-| `hasManyThrough` | `many([...chain])` |
+| Lucid relation   | Zero mapping                       |
+| ---------------- | ---------------------------------- |
+| `hasOne`         | `one(...)`                         |
+| `hasMany`        | `many(...)`                        |
+| `belongsTo`      | `one(...)`                         |
+| `manyToMany`     | `many([...chain])` via pivot table |
+| `hasManyThrough` | `many([...chain])`                 |
 
-Relations pointing to a model not found in `modelsSourcePath` are skipped with a warning.
+Relations pointing to a model not found in `modelsDirectory` are skipped with a warning.
 
 ---
 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 type ConfigInput = {
-    modelsSourcePath: string;
+    modelsDirectory?: string;
     /**
      * Models to exclude from the generated schema.
      * Typed as a constructor array rather than `LucidModel[]` so that model
@@ -8,9 +8,8 @@ type ConfigInput = {
      * without a structural mismatch from duplicate copies of the package.
      */
     excludeModels?: (abstract new (...args: any[]) => any)[];
-    output?: string;
-    prettier?: boolean;
-    columnTypes?: Record<string, Record<string, string>>;
+    outputPath?: string;
+    columnTypeOverrides?: Record<string, Record<string, string>>;
 };
 
 export type { ConfigInput as Config };

package/dist/index.js

@@ -17,61 +17,60 @@ async function getDefaultExportFromModulePath(modulePath) {
   try {
     await fs.access(modulePath);
   } catch {
-    throw new Error(`lucid-zero: Module not found at ${modulePath}`);
+    throw new Error(`Module not found at ${modulePath}`);
   }
   const { tsImport } = await import("tsx/esm/api");
   const moduleUrl = url.pathToFileURL(modulePath).href;
   const module = await tsImport(moduleUrl, { parentURL: import.meta.url });
   const defaultExport = module.default;
   if (!defaultExport) {
-    throw new Error(`lucid-zero: Module at ${modulePath} does not have a default export`);
+    throw new Error(`Module at ${modulePath} does not have a default export`);
   }
   return defaultExport;
 }
 
 // src/config.ts
-var DEFAULT_CONFIG_FILE_PATH = "lucid-zero.config.ts";
+var DEFAULT_CONFIG_FILE_PATH = "config/lucid_zero.ts";
 var DEFAULT_OUTPUT_FILE_PATH = "zero-schema.gen.ts";
+var DEFAULT_MODELS_DIRECTORY = "./app/models";
 var Config = class {
-  modelsSourcePath;
+  modelsDirectory;
   excludeModels;
   outputFilePath;
-  formatOutputFile;
-  columnTypes;
+  columnTypeOverrides;
   tsconfigPath;
-  /** Directory containing the config file — used to resolve relative paths */
-  configDir;
+  /** Working directory used to resolve relative paths */
+  cwd;
   /** Populated by this.loadModels() */
   models = [];
-  constructor(configInput, configDir = process.cwd(), tsconfigPath) {
-    this.configDir = configDir;
-    this.modelsSourcePath = configInput.modelsSourcePath;
+  constructor(configInput, tsconfigPath) {
+    this.cwd = process.cwd();
+    this.modelsDirectory = configInput.modelsDirectory ?? DEFAULT_MODELS_DIRECTORY;
     this.excludeModels = configInput.excludeModels ?? [];
-    this.outputFilePath = path.resolve(configDir, configInput.output ?? DEFAULT_OUTPUT_FILE_PATH);
-    this.tsconfigPath = tsconfigPath ?? path.resolve(configDir, "tsconfig.json");
-    this.formatOutputFile = configInput.prettier ?? false;
-    this.columnTypes = configInput.columnTypes ?? {};
+    this.outputFilePath = path.resolve(this.cwd, configInput.outputPath ?? DEFAULT_OUTPUT_FILE_PATH);
+    this.tsconfigPath = path.resolve(this.cwd, tsconfigPath ?? "tsconfig.json");
+    this.columnTypeOverrides = configInput.columnTypeOverrides ?? {};
   }
   async verify() {
-    if (!this.modelsSourcePath) {
-      throw new Error("lucid-zero: modelsSourcePath is required");
+    if (!this.modelsDirectory) {
+      throw new Error("modelsDirectory must not be empty");
     }
     await this.loadModels();
     if (this.models.length === 0) {
       throw new Error(
-        `lucid-zero: No Lucid models found in modelsSourcePath. Each model file must have a default export that extends BaseModel.`
+        `No Lucid models found in modelsDirectory. Each model file must have a default export that extends BaseModel.`
       );
     }
-    this.verifyColumnTypes();
+    this.verifyColumnTypeOverrides();
   }
   async loadModels() {
-    const modelsSourceAbsPath = path.resolve(this.configDir, this.modelsSourcePath);
+    const modelsDirectoryAbsPath = path.resolve(this.cwd, this.modelsDirectory);
     let fileNames;
     try {
-      fileNames = await fs2.readdir(modelsSourceAbsPath);
+      fileNames = await fs2.readdir(modelsDirectoryAbsPath);
     } catch (e) {
       throw new Error(
-        `lucid-zero: Could not read modelsSourcePath at ${modelsSourceAbsPath}. Does the directory exist?Error: ${e}`
+        `Could not read modelsDirectory at ${modelsDirectoryAbsPath}. Does the directory exist?Error: ${e}`
       );
     }
     const tsFileNames = fileNames.filter((f) => f.endsWith(".ts") && !f.endsWith(".d.ts"));
@@ -81,10 +80,10 @@ var Config = class {
         let defaultExport;
         try {
           defaultExport = await getDefaultExportFromModulePath(
-            path.join(modelsSourceAbsPath, fileName)
+            path.join(modelsDirectoryAbsPath, fileName)
           );
         } catch (err) {
-          console.warn(`lucid-zero: Failed to import ${fileName}, skipping: ${String(err)}`);
+          console.warn(`Failed to import ${fileName}, skipping: ${String(err)}`);
           return null;
         }
         if (!this.isLucidModel(defaultExport)) {
@@ -100,20 +99,20 @@ var Config = class {
     );
     this.models = results.filter((m) => m !== null);
   }
-  verifyColumnTypes() {
+  verifyColumnTypeOverrides() {
     const validZeroTypes = ["string", "number", "boolean", "json", "enumeration"];
     const modelNames = new Set(this.models.map((m) => m.name));
-    for (const [modelName, columnOverrides] of Object.entries(this.columnTypes ?? {})) {
+    for (const [modelName, columnOverrides] of Object.entries(this.columnTypeOverrides ?? {})) {
       if (!modelNames.has(modelName)) {
         throw new Error(
-          `lucid-zero: columnTypes has unknown model "${modelName}". Known models: ${[...modelNames].join(", ")}`
+          `columnTypeOverrides has unknown model "${modelName}". Known models: ${[...modelNames].join(", ")}`
         );
       }
       for (const [attributeName, typeString] of Object.entries(columnOverrides)) {
         const baseTypeName = typeString.match(/^([a-z]+)/)?.[1];
         if (!baseTypeName || !validZeroTypes.includes(baseTypeName)) {
           throw new Error(
-            `lucid-zero: columnTypes override for ${modelName}.${attributeName} has unrecognised type "${typeString}". Expected one of: ${validZeroTypes.join(", ")}`
+            `columnTypeOverrides override for ${modelName}.${attributeName} has unrecognised type "${typeString}". Expected one of: ${validZeroTypes.join(", ")}`
           );
         }
       }
@@ -137,11 +136,11 @@ var ConfigLoader = class {
       defaultExport = await getDefaultExportFromModulePath(absoluteConfigPath);
     } catch (err) {
       throw new Error(
-        `lucid-zero: Failed to import config at ${absoluteConfigPath}
-  Error: ${String(err)}`
+        `Failed to import config at ${absoluteConfigPath}
+  Error: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    const config = new Config(defaultExport, path.dirname(absoluteConfigPath), opts.tsconfigPath);
+    const config = new Config(defaultExport, opts.tsconfigPath);
     return config;
   }
 };
@@ -166,13 +165,13 @@ var SchemaTransformer = class {
   project;
   constructor(config, tsconfigPath) {
     this.config = config;
-    this.project = new Project({ tsConfigFilePath: tsconfigPath ?? "tsconfig.json" });
+    this.project = new Project({ tsConfigFilePath: tsconfigPath ?? config.tsconfigPath });
   }
   transform() {
     return {
       models: this.config.models.map((model) => {
         const columnNameAndTypePairs = this.extractColumnNameAndType(model);
-        const columnOverrides = this.config.columnTypes?.[model.name];
+        const columnOverrides = this.config.columnTypeOverrides?.[model.name];
         return {
           tableName: model.table,
           columns: this.mapColumns(columnNameAndTypePairs, columnOverrides, model),
@@ -190,12 +189,12 @@ var SchemaTransformer = class {
     });
     if (!modelSourceFile) {
       throw new Error(
-        `lucid-zero: Could not find source file for model ${model.name} in ${this.project.getSourceFiles().map((sourceFile) => sourceFile.getFilePath()).join(", ")}`
+        `Could not find source file for model ${model.name} in ${this.project.getSourceFiles().map((sourceFile) => sourceFile.getFilePath()).join(", ")}`
       );
     }
     const classDeclaration = modelSourceFile.getClass(model.name);
     if (!classDeclaration) {
-      throw new Error(`lucid-zero: Could not find class declaration for model ${model.name}`);
+      throw new Error(`Could not find class declaration for model ${model.name}`);
     }
     let currentClass = classDeclaration;
     while (currentClass) {
@@ -226,7 +225,7 @@ var SchemaTransformer = class {
           zeroType = tsTypeToZeroType(tsType);
         } else {
           console.warn(
-            `lucid-zero: Could not infer Zero type for ${model.name}.${attributeName}. Falling back to json(). Add a columnTypes override if this is wrong.`
+            `Could not infer Zero type for ${model.name}.${attributeName}. Falling back to json(). Add a columnTypeOverrides entry if this is wrong.`
           );
           zeroType = "json()";
         }
@@ -247,13 +246,13 @@ var SchemaTransformer = class {
         relation.boot();
       } catch (err) {
         throw new Error(
-          `lucid-zero: Failed to boot relation "${relationName}" on ${model.name}: ${String(err)}`
+          `Failed to boot relation "${relationName}" on ${model.name}: ${String(err)}`
         );
       }
       const relatedModel = relation.relatedModel();
       if (!allModels.some((m) => m.name === relatedModel.name)) {
         console.info(
-          `lucid-zero: Skipping relation "${relationName}" on ${model.name} \u2014 ${relatedModel.name} is not included.`
+          `Skipping relation "${relationName}" on ${model.name} \u2014 ${relatedModel.name} is not included.`
         );
         continue;
       }
@@ -285,7 +284,7 @@ var SchemaTransformer = class {
         case "manyToMany": {
           if (!relation.pivotTable || !relation.pivotForeignKey || !relation.pivotRelatedForeignKey) {
             throw new Error(
-              `lucid-zero: manyToMany relation "${relationName}" on ${model.name} \u2014 pivot table fields could not be resolved after boot().`
+              `manyToMany relation "${relationName}" on ${model.name} \u2014 pivot table fields could not be resolved after boot().`
             );
           }
           relationships[relationName] = {
@@ -310,7 +309,7 @@ var SchemaTransformer = class {
           const throughRel = relation;
           if (!throughRel.throughModel) {
             throw new Error(
-              `lucid-zero: hasManyThrough relation "${relationName}" on ${model.name} \u2014 throughModel could not be resolved after boot().`
+              `hasManyThrough relation "${relationName}" on ${model.name} \u2014 throughModel could not be resolved after boot().`
             );
           }
           const throughModel = throughRel.throughModel();
@@ -350,39 +349,6 @@ function tsTypeToZeroType(type) {
 
 // src/code-generator.ts
 import fs3 from "fs";
-
-// src/formatter.ts
-var Formatter = class _Formatter {
-  static async loadPrettier() {
-    let prettier;
-    try {
-      const { createRequire } = await import("module");
-      const req = createRequire(process.cwd() + "/package.json");
-      const prettierPath = req.resolve("prettier");
-      const { pathToFileURL } = await import("url");
-      prettier = await import(pathToFileURL(prettierPath).href);
-      return prettier;
-    } catch {
-      return null;
-    }
-  }
-  static async format(code) {
-    const prettier = await _Formatter.loadPrettier();
-    if (!prettier) {
-      console.warn("lucid-zero: prettier not found \u2014 skipping formatting");
-      return code;
-    }
-    try {
-      const options = await prettier.resolveConfig(process.cwd());
-      return await prettier.format(code, { ...options, parser: "typescript" });
-    } catch {
-      console.warn("lucid-zero: prettier formatting failed \u2014 skipping");
-      return code;
-    }
-  }
-};
-
-// src/code-generator.ts
 var HEADER = `// This file was automatically generated by lucid-zero.
 // Do NOT edit this file manually \u2014 it will be overwritten on the next run.`;
 var CodeGenerator = class {
@@ -393,10 +359,7 @@ var CodeGenerator = class {
     this.schema = schema;
   }
   async generateToOutputFile() {
-    let code = this.generate();
-    if (this.config.formatOutputFile) {
-      code = await Formatter.format(code);
-    }
+    const code = this.generate();
     fs3.writeFileSync(this.config.outputFilePath, code);
   }
   generate() {
@@ -548,7 +511,7 @@ async function run(options) {
   try {
     const config = await ConfigLoader.load(options);
     await config.verify();
-    const schemaTransformer = new SchemaTransformer(config, options.tsconfigPath);
+    const schemaTransformer = new SchemaTransformer(config);
     const transformedSchema = schemaTransformer.transform();
     const codeGenerator = new CodeGenerator(config, transformedSchema);
     await codeGenerator.generateToOutputFile();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antislop/zero-lucid-generator",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Generate Zero schemas from Lucid ORM models",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,13 +19,20 @@
     "check-types": "tsc --noEmit",
     "lint": "eslint src tests",
     "lint:fix": "eslint src tests --fix",
-    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
-    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\""
+    "format": "oxfmt \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format:check": "oxfmt --check \"src/**/*.ts\" \"tests/**/*.ts\""
   },
   "bin": {
-    "lucid-zero": "./dist/index.js"
+    "lucid-zero": "dist/index.js"
   },
-  "keywords": ["zero", "lucid", "adonisjs", "schema", "generator", "rocicorp"],
+  "keywords": [
+    "zero",
+    "lucid",
+    "adonisjs",
+    "schema",
+    "generator",
+    "rocicorp"
+  ],
   "author": "antislop",
   "license": "ISC",
   "publishConfig": {
@@ -43,8 +50,7 @@
     "@typescript-eslint/parser": "^8.61.0",
     "@vitest/coverage-v8": "^4.1.8",
     "eslint": "^10.4.1",
-    "eslint-config-prettier": "^10.1.8",
-    "prettier": "^3.8.4",
+    "oxfmt": "^0.54.0",
     "tsup": "^8.5.1",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",