@antislop/zero-lucid-generator 1.1.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,32 +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 |
-| `format` | `boolean` | `false` | Format the output with [oxfmt](https://oxc.rs/docs/guide/usage/formatter) (must be installed). Respects your `.oxfmtrc.json`. |
-| `excludeModels` | `LucidModel[]` | `[]` | Models to exclude from the generated schema |
-| `columnTypes` | `Record<string, Record<string, string>>` | `{}` | Override the inferred Zero type for specific columns |
-
-### Formatting with oxfmt
-
-Set `format: true` to have the generated file automatically formatted on every run:
-
-```ts
-const config: Config = {
-  modelsSourcePath: './app/models',
-  format: true,
-}
-```
-
-Install oxfmt in your project:
-
-```sh
-npm add -D oxfmt
-```
-
-The formatter picks up your `.oxfmtrc.json` / `oxfmt.config.ts` automatically, so the output will always match what your own format scripts produce.
+| 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                     |
 
 ---
 
@@ -91,8 +71,8 @@ The formatter picks up your `.oxfmtrc.json` / `oxfmt.config.ts` automatically, s
 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)
 ```
 
 ---
@@ -101,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[] }>()',
@@ -143,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,10 +8,8 @@ type ConfigInput = {
      * without a structural mismatch from duplicate copies of the package.
      */
     excludeModels?: (abstract new (...args: any[]) => any)[];
-    output?: string;
-    /** Format the output file with oxfmt. Requires oxfmt to be installed. */
-    format?: boolean;
-    columnTypes?: Record<string, Record<string, string>>;
+    outputPath?: string;
+    columnTypeOverrides?: Record<string, Record<string, string>>;
 };
 
 export type { ConfigInput as Config };

package/dist/index.js

@@ -30,48 +30,47 @@ async function getDefaultExportFromModulePath(modulePath) {
 }
 
 // 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.format ?? 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("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(
-        `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(
-        `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,7 +80,7 @@ var Config = class {
         let defaultExport;
         try {
           defaultExport = await getDefaultExportFromModulePath(
-            path.join(modelsSourceAbsPath, fileName)
+            path.join(modelsDirectoryAbsPath, fileName)
           );
         } catch (err) {
           console.warn(`Failed to import ${fileName}, skipping: ${String(err)}`);
@@ -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(
-          `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(
-            `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(", ")}`
           );
         }
       }
@@ -141,7 +140,7 @@ var ConfigLoader = class {
   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),
@@ -226,7 +225,7 @@ var SchemaTransformer = class {
           zeroType = tsTypeToZeroType(tsType);
         } else {
           console.warn(
-            `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()";
         }
@@ -350,53 +349,6 @@ function tsTypeToZeroType(type) {
 
 // src/code-generator.ts
 import fs3 from "fs";
-
-// src/formatter.ts
-import { spawnSync } from "child_process";
-import { createRequire } from "module";
-import path2 from "path";
-function resolveOxfmtBin() {
-  try {
-    const req = createRequire(process.cwd() + "/package.json");
-    const pkgMain = req.resolve("oxfmt");
-    const pkgRoot = path2.join(pkgMain, "..", "..");
-    return path2.join(pkgRoot, "bin", "oxfmt");
-  } catch {
-    return null;
-  }
-}
-var Formatter = class {
-  /**
-   * Formats `code` by piping it through the oxfmt CLI with `--stdin-filepath`
-   * set to the output file's absolute path. This lets oxfmt walk up the
-   * directory tree and discover `.oxfmtrc.json` / `oxfmt.config.ts` in the
-   * user's project.
-   */
-  static async format(code, outputFilePath) {
-    const bin = resolveOxfmtBin();
-    if (!bin) {
-      console.warn("lucid-zero: oxfmt not found \u2014 skipping formatting");
-      return code;
-    }
-    const result = spawnSync(
-      process.execPath,
-      [bin, `--stdin-filepath=${outputFilePath}`],
-      {
-        input: code,
-        encoding: "utf8",
-        cwd: process.cwd()
-      }
-    );
-    if (result.status !== 0) {
-      console.warn(`lucid-zero: oxfmt formatting failed \u2014 skipping
-${result.stderr ?? ""}`);
-      return code;
-    }
-    return result.stdout;
-  }
-};
-
-// 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 {
@@ -407,10 +359,7 @@ var CodeGenerator = class {
     this.schema = schema;
   }
   async generateToOutputFile() {
-    let code = this.generate();
-    if (this.config.formatOutputFile) {
-      code = await Formatter.format(code, this.config.outputFilePath);
-    }
+    const code = this.generate();
     fs3.writeFileSync(this.config.outputFilePath, code);
   }
   generate() {
@@ -562,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.1.0",
+  "version": "1.1.1",
   "description": "Generate Zero schemas from Lucid ORM models",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
     "format:check": "oxfmt --check \"src/**/*.ts\" \"tests/**/*.ts\""
   },
   "bin": {
-    "lucid-zero": "./dist/index.js"
+    "lucid-zero": "dist/index.js"
   },
   "keywords": [
     "zero",