@antislop/zero-lucid-generator 1.0.0

package/README.md

@@ -0,0 +1,196 @@
+# @antislop/zero-lucid-generator
+
+Generate [Zero](https://zero.rocicorp.dev) schemas directly from your [Lucid ORM](https://lucid.adonisjs.com) models — no manual schema duplication.
+
+Inspired by [`drizzle-zero`](https://github.com/rocicorp/drizzle-zero) and [`prisma-zero`](https://github.com/rocicorp/prisma-zero).
+
+---
+
+## How it works
+
+`@antislop/zero-lucid-generator` scans your Lucid model files, introspects their column and relation definitions at runtime, infers TypeScript types via [ts-morph](https://ts-morph.com), and writes a typed Zero schema file you can import directly into your app.
+
+---
+
+## Installation
+
+```sh
+npm add -D @antislop/zero-lucid-generator
+```
+
+`@antislop/zero-lucid-generator` is a dev-time generator. You only need it during development to regenerate the schema when models change.
+
+---
+
+## Setup
+
+### 1. Create a config file
+
+Create `lucid-zero.config.ts` at the root of your project:
+
+```ts
+import type { Config } from '@antislop/zero-lucid-generator'
+
+const config: Config = {
+  modelsSourcePath: './app/models',
+}
+
+export default config
+```
+
+### 2. Run the generator
+
+```sh
+npx lucid-zero generate
+```
+
+This writes `zero-schema.gen.ts` next to your config file.
+
+### 3. Import the schema
+
+```ts
+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 |
+
+---
+
+## CLI options
+
+```
+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)
+```
+
+---
+
+## Column type inference
+
+`@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()` |
+
+When inference isn't accurate — for example a JSON column with a known shape — use `columnTypes`:
+
+```ts
+import type { Config } from '@antislop/zero-lucid-generator'
+import Session from "#models/session";
+
+const config: Config = {
+  modelsSourcePath: './app/models',
+  columnTypes: {
+    Issue: {
+      // metadata is typed as `unknown` but has a known shape
+      metadata: 'json<{ priority: number; labels: string[] }>()',
+    },
+    User: {
+      // role is stored as a string enum
+      role: 'enumeration<"admin" | "member" | "viewer">()',
+    },
+  },
+  excludeModels: [Session],
+}
+
+export default config
+```
+
+Valid Zero base types: `string`, `number`, `boolean`, `json`, `enumeration`.
+
+---
+
+## Example output
+
+```ts
+// zero-schema.gen.ts (auto-generated — do not edit)
+
+import {
+  createBuilder,
+  createSchema,
+  number,
+  relationships,
+  string,
+  table,
+} from "@rocicorp/zero";
+
+export const users = table("users")
+  .columns({
+    id: number(),
+    name: string(),
+    email: string(),
+  })
+  .primaryKey("id");
+
+export const posts = table("posts")
+  .columns({
+    id: number(),
+    userId: number().from('user_id'),
+    title: string(),
+    body: string().optional(),
+  })
+  .primaryKey("id");
+
+export const usersRelationships = relationships(users, ({ many }) => ({
+  posts: many({
+    sourceField: ["id"],
+    destField: ["userId"],
+    destSchema: posts,
+  }),
+}));
+
+export const schema = createSchema({
+  tables: [users, posts],
+  relationships: [usersRelationships],
+});
+
+export type Schema = typeof 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])` |
+
+Relations pointing to a model not found in `modelsSourcePath` are skipped with a warning.
+
+---
+
+## Automating regeneration
+
+Add a script to `package.json` to regenerate whenever models change:
+
+```json
+{
+  "scripts": {
+    "zero:generate": "lucid-zero generate",
+    "postinstall": "npm run zero:generate"
+  }
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+type ConfigInput = {
+    modelsSourcePath: string;
+    /**
+     * Models to exclude from the generated schema.
+     * Typed as a constructor array rather than `LucidModel[]` so that model
+     * classes from the user's own `@adonisjs/lucid` installation are accepted
+     * 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>>;
+};
+
+export type { ConfigInput as Config };

package/dist/index.js

@@ -0,0 +1,560 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config.ts
+import fs2 from "fs/promises";
+import path from "path";
+
+// src/utils.ts
+import url from "url";
+import fs from "fs/promises";
+function toCamelCase(name) {
+  return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+async function getDefaultExportFromModulePath(modulePath) {
+  try {
+    await fs.access(modulePath);
+  } catch {
+    throw new Error(`lucid-zero: 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`);
+  }
+  return defaultExport;
+}
+
+// src/config.ts
+var DEFAULT_CONFIG_FILE_PATH = "lucid-zero.config.ts";
+var DEFAULT_OUTPUT_FILE_PATH = "zero-schema.gen.ts";
+var Config = class {
+  modelsSourcePath;
+  excludeModels;
+  outputFilePath;
+  formatOutputFile;
+  columnTypes;
+  tsconfigPath;
+  /** Directory containing the config file — used to resolve relative paths */
+  configDir;
+  /** Populated by this.loadModels() */
+  models = [];
+  constructor(configInput, configDir = process.cwd(), tsconfigPath) {
+    this.configDir = configDir;
+    this.modelsSourcePath = configInput.modelsSourcePath;
+    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 ?? {};
+  }
+  async verify() {
+    if (!this.modelsSourcePath) {
+      throw new Error("lucid-zero: modelsSourcePath is required");
+    }
+    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.`
+      );
+    }
+    this.verifyColumnTypes();
+  }
+  async loadModels() {
+    const modelsSourceAbsPath = path.resolve(this.configDir, this.modelsSourcePath);
+    let fileNames;
+    try {
+      fileNames = await fs2.readdir(modelsSourceAbsPath);
+    } catch (e) {
+      throw new Error(
+        `lucid-zero: Could not read modelsSourcePath at ${modelsSourceAbsPath}. Does the directory exist?Error: ${e}`
+      );
+    }
+    const tsFileNames = fileNames.filter((f) => f.endsWith(".ts") && !f.endsWith(".d.ts"));
+    const excludedModelNames = new Set((this.excludeModels ?? []).map((m) => m.name));
+    const results = await Promise.all(
+      tsFileNames.map(async (fileName) => {
+        let defaultExport;
+        try {
+          defaultExport = await getDefaultExportFromModulePath(
+            path.join(modelsSourceAbsPath, fileName)
+          );
+        } catch (err) {
+          console.warn(`lucid-zero: Failed to import ${fileName}, skipping: ${String(err)}`);
+          return null;
+        }
+        if (!this.isLucidModel(defaultExport)) {
+          console.info(`${fileName} does not export a Lucid model. Skipping...`);
+          return null;
+        }
+        if (excludedModelNames.has(defaultExport.name)) {
+          console.info(`${defaultExport.name} is excluded. Skipping...`);
+          return null;
+        }
+        return defaultExport;
+      })
+    );
+    this.models = results.filter((m) => m !== null);
+  }
+  verifyColumnTypes() {
+    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 ?? {})) {
+      if (!modelNames.has(modelName)) {
+        throw new Error(
+          `lucid-zero: columnTypes 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(", ")}`
+          );
+        }
+      }
+    }
+  }
+  isLucidModel(value) {
+    return (
+      // The class itself is a constructor function
+      typeof value === "function" && "$columnsDefinitions" in value && value.$columnsDefinitions instanceof Map
+    );
+  }
+};
+var ConfigLoader = class {
+  static async load(opts) {
+    const absoluteConfigPath = path.resolve(
+      process.cwd(),
+      opts.configFilePath ?? DEFAULT_CONFIG_FILE_PATH
+    );
+    let defaultExport;
+    try {
+      defaultExport = await getDefaultExportFromModulePath(absoluteConfigPath);
+    } catch (err) {
+      throw new Error(
+        `lucid-zero: Failed to import config at ${absoluteConfigPath}
+  Error: ${String(err)}`
+      );
+    }
+    const config = new Config(defaultExport, path.dirname(absoluteConfigPath), opts.tsconfigPath);
+    return config;
+  }
+};
+
+// src/schema-transformer.ts
+import { Project } from "ts-morph";
+var typesToZeroTypes = {
+  string: "string()",
+  number: "number()",
+  boolean: "boolean()",
+  // Lucid date columns are typed as Luxon DateTime
+  DateTime: "number()",
+  // Plain JS Date falls back to number (epoch ms)
+  Date: "number()",
+  // Catch-all for object/unknown shapes
+  object: "json()",
+  unknown: "json()",
+  any: "json()"
+};
+var SchemaTransformer = class {
+  config;
+  project;
+  constructor(config, tsconfigPath) {
+    this.config = config;
+    this.project = new Project({ tsConfigFilePath: tsconfigPath ?? "tsconfig.json" });
+  }
+  transform() {
+    return {
+      models: this.config.models.map((model) => {
+        const columnNameAndTypePairs = this.extractColumnNameAndType(model);
+        const columnOverrides = this.config.columnTypes?.[model.name];
+        return {
+          tableName: model.table,
+          columns: this.mapColumns(columnNameAndTypePairs, columnOverrides, model),
+          relationships: this.mapRelations(model, this.config.models),
+          primaryKey: [model.primaryKey]
+        };
+      })
+    };
+  }
+  // Lucid Model does not offer the type of the columns, so we need to extract it from the source code
+  extractColumnNameAndType(model) {
+    const columnNameAndType = /* @__PURE__ */ new Map();
+    const modelSourceFile = this.project.getSourceFiles().find((sourceFile) => {
+      return sourceFile.getClass(model.name)?.getName() === model.name;
+    });
+    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(", ")}`
+      );
+    }
+    const classDeclaration = modelSourceFile.getClass(model.name);
+    if (!classDeclaration) {
+      throw new Error(`lucid-zero: Could not find class declaration for model ${model.name}`);
+    }
+    let currentClass = classDeclaration;
+    while (currentClass) {
+      for (const property of currentClass.getProperties()) {
+        const attributeName = property.getName();
+        if (!model.$columnsDefinitions.has(attributeName)) continue;
+        if (columnNameAndType.has(attributeName)) continue;
+        const explicitPropertyType = property.getTypeNode();
+        if (explicitPropertyType) {
+          columnNameAndType.set(attributeName, explicitPropertyType.getText());
+        } else {
+          columnNameAndType.set(attributeName, property.getType().getText());
+        }
+      }
+      currentClass = currentClass.getBaseClass();
+    }
+    return columnNameAndType;
+  }
+  mapColumns(typescriptColumnTypes, columnTypeOverrides, model) {
+    return Object.fromEntries(
+      [...model.$columnsDefinitions].map(([attributeName, columnOptions]) => {
+        const tsType = typescriptColumnTypes.get(attributeName);
+        const override = columnTypeOverrides?.[attributeName];
+        let zeroType;
+        if (override) {
+          zeroType = override;
+        } else if (tsType) {
+          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.`
+          );
+          zeroType = "json()";
+        }
+        const isOptional = !columnOptions.isPrimary && isTsTypeOptional(tsType);
+        return [columnOptions.columnName, { type: zeroType, isOptional }];
+      })
+    );
+  }
+  /** Translates a Lucid attribute name to its DB column name via $columnsDefinitions. */
+  resolveColumnName(lucidModel, attributeName) {
+    const entry = [...lucidModel.$columnsDefinitions].find(([attr]) => attr === attributeName);
+    return entry ? entry[1].columnName : attributeName;
+  }
+  mapRelations(model, allModels) {
+    const relationships = {};
+    for (const [relationName, relation] of model.$relationsDefinitions) {
+      try {
+        relation.boot();
+      } catch (err) {
+        throw new Error(
+          `lucid-zero: 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.`
+        );
+        continue;
+      }
+      switch (relation.type) {
+        case "hasOne":
+          relationships[relationName] = {
+            type: "one",
+            sourceField: [this.resolveColumnName(model, relation.localKey)],
+            destinationField: [this.resolveColumnName(relatedModel, relation.foreignKey)],
+            destinationTable: relatedModel.table
+          };
+          break;
+        case "belongsTo":
+          relationships[relationName] = {
+            type: "one",
+            sourceField: [this.resolveColumnName(model, relation.foreignKey)],
+            destinationField: [this.resolveColumnName(relatedModel, relation.localKey)],
+            destinationTable: relatedModel.table
+          };
+          break;
+        case "hasMany":
+          relationships[relationName] = {
+            type: "many",
+            sourceField: [this.resolveColumnName(model, relation.localKey)],
+            destinationField: [this.resolveColumnName(relatedModel, relation.foreignKey)],
+            destinationTable: relatedModel.table
+          };
+          break;
+        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().`
+            );
+          }
+          relationships[relationName] = {
+            type: "many",
+            chain: [
+              {
+                sourceField: [this.resolveColumnName(model, relation.localKey)],
+                // pivotForeignKey and pivotRelatedForeignKey are already DB column names
+                destinationField: [relation.pivotForeignKey],
+                destinationTable: relation.pivotTable
+              },
+              {
+                sourceField: [relation.pivotRelatedForeignKey],
+                destinationField: [this.resolveColumnName(relatedModel, relation.relatedKey ?? relatedModel.primaryKey)],
+                destinationTable: relatedModel.table
+              }
+            ]
+          };
+          break;
+        }
+        case "hasManyThrough": {
+          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().`
+            );
+          }
+          const throughModel = throughRel.throughModel();
+          relationships[relationName] = {
+            type: "many",
+            chain: [
+              {
+                sourceField: [this.resolveColumnName(model, relation.localKey)],
+                destinationField: [this.resolveColumnName(throughModel, relation.foreignKey)],
+                destinationTable: throughModel.table
+              },
+              {
+                sourceField: [this.resolveColumnName(throughModel, throughRel.throughLocalKey ?? throughModel.primaryKey)],
+                destinationField: [this.resolveColumnName(relatedModel, throughRel.throughForeignKey ?? relatedModel.primaryKey)],
+                destinationTable: relatedModel.table
+              }
+            ]
+          };
+          break;
+        }
+      }
+    }
+    return relationships;
+  }
+};
+function isTsTypeOptional(type) {
+  if (!type) {
+    return false;
+  }
+  return type.includes("null") || type.includes("undefined");
+}
+function tsTypeToZeroType(type) {
+  const base = type.split("|").map((t) => t.trim()).find((t) => t !== "null" && t !== "undefined");
+  if (!base) return "json()";
+  return typesToZeroTypes[base] ?? "json()";
+}
+
+// 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 {
+  config;
+  schema;
+  constructor(config, schema) {
+    this.config = config;
+    this.schema = schema;
+  }
+  async generateToOutputFile() {
+    let code = this.generate();
+    if (this.config.formatOutputFile) {
+      code = await Formatter.format(code);
+    }
+    fs3.writeFileSync(this.config.outputFilePath, code);
+  }
+  generate() {
+    let out = HEADER + "\n\n";
+    out += this.generateImports();
+    for (const model of this.schema.models) {
+      out += this.generateTableDefinitions(model) + "\n";
+    }
+    for (const model of this.schema.models) {
+      const rel = this.generateRelationshipsDefinitions(model);
+      if (rel) out += rel + "\n";
+    }
+    out += this.generateExports();
+    return out;
+  }
+  generateImports() {
+    const used = /* @__PURE__ */ new Set(["table", "createSchema", "createBuilder"]);
+    for (const model of this.schema.models) {
+      for (const col of Object.values(model.columns)) {
+        const baseTypeName = col.type.match(/^([a-z]+)/)?.[1];
+        if (baseTypeName) used.add(baseTypeName);
+      }
+      if (Object.keys(model.relationships).length > 0) {
+        used.add("relationships");
+      }
+    }
+    const sorted = [...used].sort();
+    return `import {
+  ${sorted.join(",\n  ")},
+} from "@rocicorp/zero";
+
+`;
+  }
+  generateColumnDefinitions(dbColName, col) {
+    const zeroColName = this.toZeroName(dbColName);
+    let expr = col.type;
+    if (zeroColName !== dbColName) {
+      expr += `.from('${dbColName}')`;
+    }
+    if (col.isOptional) {
+      expr += `.optional()`;
+    }
+    return `    ${zeroColName}: ${expr}`;
+  }
+  toZeroName(name) {
+    return toCamelCase(name);
+  }
+  relationshipVariableName(model) {
+    return toCamelCase(model.tableName) + "Relationships";
+  }
+  generateTableDefinitions(model) {
+    const zeroName = this.toZeroName(model.tableName);
+    let out = `export const ${zeroName} = table("${zeroName}")`;
+    if (zeroName !== model.tableName) {
+      out += `
+  .from("${model.tableName}")`;
+    }
+    out += "\n  .columns({\n";
+    for (const [dbColName, col] of Object.entries(model.columns)) {
+      out += this.generateColumnDefinitions(dbColName, col) + ",\n";
+    }
+    out += "  })";
+    out += `
+  .primaryKey(${model.primaryKey.map((k) => `"${this.toZeroName(k)}"`).join(", ")});
+`;
+    return out;
+  }
+  generateRelationshipsDefinitions(model) {
+    const relationEntries = Object.entries(model.relationships);
+    if (relationEntries.length === 0) return "";
+    const hasOne = relationEntries.some(([, rel]) => rel.type === "one");
+    const hasMany = relationEntries.some(([, rel]) => rel.type === "many");
+    const destructured = [hasOne && "one", hasMany && "many"].filter(Boolean).join(", ");
+    const zeroName = this.toZeroName(model.tableName);
+    const body = relationEntries.map(([name, rel]) => `  ${this.toZeroName(name)}: ${rel.type}(${this.generateRelationshipConfig(rel)})`).join(",\n");
+    return `export const ${this.relationshipVariableName(model)} = relationships(${zeroName}, ({ ${destructured} }) => ({
+${body}
+}));
+`;
+  }
+  zeroFields(fields) {
+    return JSON.stringify(fields.map((f) => this.toZeroName(f)));
+  }
+  generateRelationshipConfig(rel) {
+    if ("chain" in rel) {
+      return rel.chain.map((link) => [
+        `{`,
+        `      sourceField: ${this.zeroFields(link.sourceField)},`,
+        `      destField: ${this.zeroFields(link.destinationField)},`,
+        `      destSchema: ${this.toZeroName(link.destinationTable)},`,
+        `    }`
+      ].join("\n")).join(", ");
+    }
+    return [
+      `{`,
+      `    sourceField: ${this.zeroFields(rel.sourceField)},`,
+      `    destField: ${this.zeroFields(rel.destinationField)},`,
+      `    destSchema: ${this.toZeroName(rel.destinationTable)},`,
+      `  }`
+    ].join("\n");
+  }
+  generateExports() {
+    const hasRelationships = this.schema.models.some(
+      (model) => Object.keys(model.relationships).length > 0
+    );
+    let out = `
+export const schema = createSchema({
+`;
+    out += `  tables: [
+`;
+    for (const model of this.schema.models) {
+      out += `    ${this.toZeroName(model.tableName)},
+`;
+    }
+    out += `  ],
+`;
+    if (hasRelationships) {
+      out += `  relationships: [
+`;
+      for (const model of this.schema.models) {
+        if (Object.keys(model.relationships).length > 0) {
+          out += `    ${this.relationshipVariableName(model)},
+`;
+        }
+      }
+      out += `  ],
+`;
+    }
+    out += `});
+
+`;
+    out += `export type Schema = typeof schema;
+`;
+    out += `
+export const zql = createBuilder(schema);
+`;
+    return out;
+  }
+};
+
+// src/index.ts
+var program = new Command();
+program.name("lucid-zero").description("Generate Zero schemas from Lucid ORM model definitions");
+program.command("generate").description("Generate a Zero schema from your Lucid models").option("-c, --config <path>", `Path to config file (default: ${DEFAULT_CONFIG_FILE_PATH})`).option("-t, --tsconfig <path>", `Path to tsconfig file (default: tsconfig.json)`).action(async (opts) => {
+  await run({ configFilePath: opts.config, tsconfigPath: opts.tsconfig });
+});
+program.parse();
+async function run(options) {
+  try {
+    const config = await ConfigLoader.load(options);
+    await config.verify();
+    const schemaTransformer = new SchemaTransformer(config, options.tsconfigPath);
+    const transformedSchema = schemaTransformer.transform();
+    const codeGenerator = new CodeGenerator(config, transformedSchema);
+    await codeGenerator.generateToOutputFile();
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(`lucid-zero: ${message}`);
+    process.exit(1);
+  }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@antislop/zero-lucid-generator",
+  "version": "1.0.0",
+  "description": "Generate Zero schemas from Lucid ORM models",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && npx tsx build.ts && chmod +x dist/index.js",
+    "test": "vitest run --typecheck --coverage",
+    "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\""
+  },
+  "bin": {
+    "lucid-zero": "./dist/index.js"
+  },
+  "keywords": ["zero", "lucid", "adonisjs", "schema", "generator", "rocicorp"],
+  "author": "antislop",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "npm@11.12.1",
+  "type": "module",
+  "peerDependencies": {
+    "@adonisjs/lucid": ">=21.0.0"
+  },
+  "devDependencies": {
+    "@adonisjs/lucid": "^22.4.2",
+    "@types/node": "^25.9.2",
+    "@typescript-eslint/eslint-plugin": "^8.61.0",
+    "@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",
+    "tsup": "^8.5.1",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  },
+  "dependencies": {
+    "commander": "^15.0.0",
+    "ts-morph": "^28.0.0",
+    "tsx": "^4.22.4"
+  }
+}