js-bao 0.2.8

package/dist/codegen.cjs

@@ -0,0 +1,1325 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/codegen.ts
+var import_commander = require("commander");
+var path3 = __toESM(require("path"), 1);
+
+// src/cli/utils/FileUtils.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_util = require("util");
+var readFile2 = (0, import_util.promisify)(fs.readFile);
+var writeFile2 = (0, import_util.promisify)(fs.writeFile);
+var readdir2 = (0, import_util.promisify)(fs.readdir);
+var stat2 = (0, import_util.promisify)(fs.stat);
+var mkdir2 = (0, import_util.promisify)(fs.mkdir);
+var FileUtils = class {
+  /**
+   * Recursively find all TypeScript files in a directory
+   */
+  static async findTSFiles(dir, exclude = []) {
+    const files = [];
+    const isExcluded = (filePath) => {
+      return exclude.some((pattern) => {
+        if (pattern.includes("*")) {
+          const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+          return regex.test(filePath);
+        }
+        return filePath.includes(pattern);
+      });
+    };
+    const scanDirectory = async (currentDir) => {
+      try {
+        const entries = await readdir2(currentDir);
+        for (const entry of entries) {
+          const fullPath = path.join(currentDir, entry);
+          const stats = await stat2(fullPath);
+          if (stats.isDirectory()) {
+            if (!isExcluded(fullPath)) {
+              await scanDirectory(fullPath);
+            }
+          } else if (stats.isFile() && entry.endsWith(".ts") && !entry.endsWith(".d.ts")) {
+            if (!isExcluded(fullPath)) {
+              files.push(fullPath);
+            }
+          }
+        }
+      } catch (error) {
+        console.warn(
+          `[FileUtils] Could not scan directory ${currentDir}:`,
+          error
+        );
+      }
+    };
+    await scanDirectory(dir);
+    return files;
+  }
+  /**
+   * Read and return the content of a file
+   */
+  static async readFileContent(filePath) {
+    try {
+      return await readFile2(filePath, "utf8");
+    } catch (error) {
+      throw new Error(`Failed to read file ${filePath}: ${error}`);
+    }
+  }
+  /**
+   * Write content to a file, creating directories if necessary
+   */
+  static async writeFileContent(filePath, content) {
+    try {
+      const dir = path.dirname(filePath);
+      await this.ensureDirectoryExists(dir);
+      await writeFile2(filePath, content, "utf8");
+    } catch (error) {
+      throw new Error(`Failed to write file ${filePath}: ${error}`);
+    }
+  }
+  /**
+   * Ensure a directory exists, creating it recursively if necessary
+   */
+  static async ensureDirectoryExists(dirPath) {
+    try {
+      await stat2(dirPath);
+    } catch {
+      await mkdir2(dirPath, { recursive: true });
+    }
+  }
+  /**
+   * Get relative path from one file to another
+   */
+  static getRelativePath(from, to) {
+    let relativePath = path.relative(path.dirname(from), to);
+    if (relativePath.endsWith(".ts")) {
+      relativePath = relativePath.slice(0, -3);
+    }
+    if (!relativePath.startsWith(".")) {
+      relativePath = "./" + relativePath;
+    }
+    return relativePath;
+  }
+  /**
+   * Check if a file exists
+   */
+  static async fileExists(filePath) {
+    try {
+      await stat2(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/cli/analyzers/ModelAnalyzer.ts
+var ts = __toESM(require("typescript"), 1);
+
+// src/cli/utils/Logger.ts
+var Logger = class _Logger {
+  static isVerbose = false;
+  static setVerbose(verbose) {
+    _Logger.isVerbose = verbose;
+  }
+  static log(message, prefix) {
+    const fullMessage = prefix ? `[${prefix}] ${message}` : message;
+    console.log(fullMessage);
+  }
+  static verbose(message, prefix) {
+    if (_Logger.isVerbose) {
+      const fullMessage = prefix ? `[${prefix}] ${message}` : message;
+      console.log(fullMessage);
+    }
+  }
+  static warn(message, prefix) {
+    const fullMessage = prefix ? `[${prefix}] ${message}` : message;
+    console.warn(fullMessage);
+  }
+  static error(message, prefix) {
+    const fullMessage = prefix ? `[${prefix}] ${message}` : message;
+    console.error(fullMessage);
+  }
+};
+
+// src/cli/analyzers/ModelAnalyzer.ts
+var ModelAnalyzer = class {
+  program;
+  verbose;
+  constructor(filePaths, verbose = false) {
+    this.verbose = verbose;
+    this.program = ts.createProgram(filePaths, {
+      target: ts.ScriptTarget.ES2020,
+      module: ts.ModuleKind.CommonJS,
+      allowJs: false,
+      declaration: true,
+      esModuleInterop: true,
+      skipLibCheck: true
+    });
+  }
+  /**
+   * Analyze all model files and extract metadata
+   */
+  async analyzeModels() {
+    const models = [];
+    for (const sourceFile of this.program.getSourceFiles()) {
+      if (sourceFile.isDeclarationFile) continue;
+      const modelMetadata = this.analyzeFile(sourceFile);
+      if (modelMetadata) {
+        Logger.verbose(
+          `Found model: ${modelMetadata.className} with ${Object.keys(modelMetadata.relationships).length} relationships`,
+          "ModelAnalyzer"
+        );
+        models.push(modelMetadata);
+      }
+    }
+    return models;
+  }
+  /**
+   * Analyze a single file for model definitions
+   */
+  analyzeFile(sourceFile) {
+    let modelMetadata = null;
+    const schemaDefinitions = this.extractSchemaDefinitions(sourceFile);
+    const attachedSchemas = this.extractAttachedSchemas(sourceFile);
+    const visit = (node) => {
+      if (modelMetadata) return;
+      if (ts.isClassDeclaration(node) && node.name) {
+        const className = node.name.text;
+        if (this.extendsBaseModel(node)) {
+          Logger.verbose(`${className} extends BaseModel`, "ModelAnalyzer");
+          const schemaMetadata = this.findSchemaForClass(
+            node,
+            schemaDefinitions,
+            attachedSchemas
+          );
+          if (schemaMetadata) {
+            modelMetadata = {
+              className,
+              modelName: schemaMetadata.modelName,
+              schemaIdentifier: schemaMetadata.identifier,
+              filePath: sourceFile.fileName,
+              relationships: schemaMetadata.relationships,
+              fields: {}
+            };
+          }
+        }
+      } else if (ts.isVariableStatement(node)) {
+        const metadataFromFactory = this.extractCreateModelClassMetadata(
+          node,
+          schemaDefinitions,
+          sourceFile.fileName
+        );
+        if (metadataFromFactory) {
+          modelMetadata = metadataFromFactory;
+        }
+      }
+      if (!modelMetadata) {
+        ts.forEachChild(node, visit);
+      }
+    };
+    visit(sourceFile);
+    return modelMetadata;
+  }
+  /**
+   * Check if a class extends BaseModel
+   */
+  extendsBaseModel(node) {
+    if (!node.heritageClauses) return false;
+    for (const heritage of node.heritageClauses) {
+      if (heritage.token === ts.SyntaxKind.ExtendsKeyword) {
+        for (const type of heritage.types) {
+          if (ts.isIdentifier(type.expression) && type.expression.text === "BaseModel") {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Extract defineModelSchema declarations
+   */
+  extractSchemaDefinitions(sourceFile) {
+    const schemas = /* @__PURE__ */ new Map();
+    const visit = (node) => {
+      if (ts.isVariableStatement(node) && node.declarationList.declarations.length > 0) {
+        for (const declaration of node.declarationList.declarations) {
+          if (declaration.name && ts.isIdentifier(declaration.name) && declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.text === "defineModelSchema" && declaration.initializer.arguments.length > 0) {
+            const arg = declaration.initializer.arguments[0];
+            if (ts.isObjectLiteralExpression(arg)) {
+              const schemaInfo = this.parseSchemaObject(arg);
+              if (schemaInfo) {
+                schemas.set(declaration.name.text, {
+                  identifier: declaration.name.text,
+                  ...schemaInfo
+                });
+              }
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return schemas;
+  }
+  parseSchemaObject(obj) {
+    let modelName = null;
+    let relationships = {};
+    for (const property of obj.properties) {
+      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+        const propName = property.name.text;
+        if (propName === "name" && ts.isStringLiteral(property.initializer)) {
+          modelName = property.initializer.text;
+        } else if (propName === "options" && ts.isObjectLiteralExpression(property.initializer)) {
+          relationships = this.parseRelationshipsFromOptions(property.initializer);
+        }
+      }
+    }
+    return modelName ? { modelName, relationships } : null;
+  }
+  parseRelationshipsFromOptions(obj) {
+    for (const property of obj.properties) {
+      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+        if (property.name.text === "relationships" && ts.isObjectLiteralExpression(property.initializer)) {
+          return this.parseRelationships(property.initializer);
+        }
+      }
+    }
+    return {};
+  }
+  /**
+   * Parse relationships object from @Model decorator
+   */
+  parseRelationships(obj) {
+    const relationships = {};
+    Logger.verbose(
+      `parseRelationships - properties count: ${obj.properties.length}`,
+      "ModelAnalyzer"
+    );
+    for (const property of obj.properties) {
+      Logger.verbose(`Processing property: ${property.kind}`, "ModelAnalyzer");
+      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+        const relationshipName = property.name.text;
+        Logger.verbose(
+          `Found relationship property: ${relationshipName}`,
+          "ModelAnalyzer"
+        );
+        let objLiteral = null;
+        if (ts.isObjectLiteralExpression(property.initializer)) {
+          Logger.verbose(
+            "Property initializer is object literal",
+            "ModelAnalyzer"
+          );
+          objLiteral = property.initializer;
+        } else if (ts.isAsExpression(property.initializer) && ts.isObjectLiteralExpression(property.initializer.expression)) {
+          Logger.verbose(
+            "Property initializer is object literal with type assertion",
+            "ModelAnalyzer"
+          );
+          objLiteral = property.initializer.expression;
+        } else {
+          Logger.verbose(
+            `Property initializer is not object literal: ${property.initializer.kind}`,
+            "ModelAnalyzer"
+          );
+        }
+        if (objLiteral) {
+          const config = this.parseRelationshipConfig(objLiteral);
+          Logger.verbose("Parsed config:", "ModelAnalyzer");
+          if (this.verbose) {
+            console.log(config);
+          }
+          if (config) {
+            relationships[relationshipName] = config;
+          }
+        }
+      }
+    }
+    return relationships;
+  }
+  findSchemaForClass(node, schemaDefinitions, attachedSchemas) {
+    if (!node.members) return null;
+    for (const member of node.members) {
+      if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name) && member.name.text === "schema" && member.initializer && ts.isIdentifier(member.initializer)) {
+        const schema = schemaDefinitions.get(member.initializer.text);
+        if (schema) return schema;
+      }
+    }
+    for (const member of node.members) {
+      if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) && member.name.text === "getSchema" && member.body) {
+        for (const statement of member.body.statements) {
+          if (ts.isReturnStatement(statement) && statement.expression && ts.isCallExpression(statement.expression) && ts.isPropertyAccessExpression(statement.expression.expression) && ts.isIdentifier(statement.expression.expression.expression)) {
+            const schemaName = statement.expression.expression.expression.text;
+            const schema = schemaDefinitions.get(schemaName);
+            if (schema) return schema;
+          }
+        }
+      }
+    }
+    const attachedSchemaName = node.name ? attachedSchemas.get(node.name.text) : void 0;
+    if (attachedSchemaName) {
+      const schema = schemaDefinitions.get(attachedSchemaName);
+      if (schema) {
+        return schema;
+      }
+    }
+    return null;
+  }
+  extractAttachedSchemas(sourceFile) {
+    const attachments = /* @__PURE__ */ new Map();
+    const visit = (node) => {
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && (node.expression.text === "attachAndRegisterModel" || node.expression.text === "attachSchemaToClass")) {
+        const [modelArg, schemaArg] = node.arguments;
+        if (modelArg && schemaArg && ts.isIdentifier(modelArg) && ts.isIdentifier(schemaArg)) {
+          attachments.set(modelArg.text, schemaArg.text);
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return attachments;
+  }
+  extractCreateModelClassMetadata(node, schemaDefinitions, filePath) {
+    for (const declaration of node.declarationList.declarations) {
+      if (declaration.name && ts.isIdentifier(declaration.name) && declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.text === "createModelClass" && declaration.initializer.arguments.length > 0) {
+        const config = declaration.initializer.arguments[0];
+        if (ts.isObjectLiteralExpression(config)) {
+          for (const property of config.properties) {
+            if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === "schema" && ts.isIdentifier(property.initializer)) {
+              const schema = schemaDefinitions.get(
+                property.initializer.text
+              );
+              if (schema) {
+                return {
+                  className: declaration.name.text,
+                  modelName: schema.modelName,
+                  schemaIdentifier: schema.identifier,
+                  filePath,
+                  relationships: schema.relationships,
+                  fields: {}
+                };
+              }
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Parse individual relationship configuration
+   */
+  parseRelationshipConfig(obj) {
+    const config = {};
+    for (const property of obj.properties) {
+      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+        const propName = property.name.text;
+        if (ts.isStringLiteral(property.initializer)) {
+          config[propName] = property.initializer.text;
+        }
+      }
+    }
+    if (config.type && config.model) {
+      return config;
+    }
+    return null;
+  }
+  /**
+   * Extract field information from class
+   */
+  extractFields(node) {
+    const fields = {};
+    for (const member of node.members) {
+      if (ts.isPropertyDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+        const fieldName = member.name.text;
+        const field = {
+          name: fieldName,
+          type: this.getTypeString(member.type),
+          isOptional: !!member.questionToken
+        };
+        const memberDecorators = ts.getDecorators?.(member) || member.decorators;
+        if (memberDecorators) {
+          for (const decorator of memberDecorators) {
+            if (ts.isCallExpression(decorator.expression) && ts.isIdentifier(decorator.expression.expression) && decorator.expression.expression.text === "Field") {
+              field.decoratorOptions = {};
+            }
+          }
+        }
+        fields[fieldName] = field;
+      }
+    }
+    return fields;
+  }
+  /**
+   * Get string representation of a type
+   */
+  getTypeString(typeNode) {
+    if (!typeNode) return "any";
+    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+      return typeNode.typeName.text;
+    }
+    switch (typeNode.kind) {
+      case ts.SyntaxKind.StringKeyword:
+        return "string";
+      case ts.SyntaxKind.NumberKeyword:
+        return "number";
+      case ts.SyntaxKind.BooleanKeyword:
+        return "boolean";
+      default:
+        return "any";
+    }
+  }
+};
+
+// src/cli/generators/RelationshipTypeGenerator.ts
+var path2 = __toESM(require("path"), 1);
+var AUTO_HEADER_START = createMarker(
+  "BEGIN",
+  "HEADER",
+  "AUTO-GENERATED HEADER"
+);
+var AUTO_HEADER_END = createMarker("END", "HEADER", "AUTO-GENERATED HEADER");
+var AUTO_FOOTER_START = createMarker(
+  "BEGIN",
+  "FOOTER",
+  "AUTO-GENERATED FOOTER"
+);
+var AUTO_FOOTER_END = createMarker("END", "FOOTER", "AUTO-GENERATED FOOTER");
+var LEGACY_HEADER_START = "// \u{1F525}\u{1F525} BEGIN AUTO-GENERATED HEADER \u{1F525}\u{1F525}";
+var LEGACY_HEADER_END = "// \u{1F525}\u{1F525} END AUTO-GENERATED HEADER \u{1F525}\u{1F525}";
+var LEGACY_FOOTER_START = "// \u{1F525}\u{1F525} BEGIN AUTO-GENERATED FOOTER \u{1F525}\u{1F525}";
+var LEGACY_FOOTER_END = "// \u{1F525}\u{1F525} END AUTO-GENERATED FOOTER \u{1F525}\u{1F525}";
+function createMarker(pos, section, label) {
+  return `// \u{1F525}\u{1F525} ${pos} ${label} (DO NOT EDIT) \u{1F525}\u{1F525}`;
+}
+var RelationshipTypeGenerator = class {
+  models;
+  options;
+  modelsByName;
+  constructor(models, options) {
+    this.models = models;
+    this.options = options;
+    this.modelsByName = new Map(models.map((m) => [m.modelName, m]));
+  }
+  /**
+   * Check if we're running in a consumer project (has js-bao as dependency)
+   */
+  isConsumerProject() {
+    try {
+      const packageJsonPath = path2.resolve(process.cwd(), "package.json");
+      if (!require("fs").existsSync(packageJsonPath)) {
+        return false;
+      }
+      const packageJson = JSON.parse(
+        require("fs").readFileSync(packageJsonPath, "utf8")
+      );
+      return !!(packageJson.dependencies?.["js-bao"] || packageJson.devDependencies?.["js-bao"]);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Generate TypeScript declaration files for all relationships
+   */
+  async generateTypeDeclarations() {
+    Logger.verbose(
+      "Generating type declarations...",
+      "RelationshipTypeGenerator"
+    );
+    if (!this.options.generatePerModelFiles) {
+      await this.generateSingleFile();
+    }
+    await this.generatePerModelFiles();
+    await this.updateModelTemplates();
+    Logger.verbose(
+      "Type declarations generated successfully.",
+      "RelationshipTypeGenerator"
+    );
+  }
+  /**
+   * Generate a single file with all relationship declarations
+   */
+  async generateSingleFile() {
+    const imports = this.generateImports();
+    const declarations = this.generateAllDeclarations();
+    const content = this.buildFileContent(imports, declarations);
+    const outputPath = path2.join(this.options.outputDir, "relationships.d.ts");
+    await FileUtils.writeFileContent(outputPath, content);
+    Logger.verbose(`Generated ${outputPath}`, "RelationshipTypeGenerator");
+    const tsContent = this.buildModuleFileContent(imports, declarations);
+    const tsOutputPath = path2.join(this.options.outputDir, "relationships.ts");
+    await FileUtils.writeFileContent(tsOutputPath, tsContent);
+    Logger.verbose(`Generated ${tsOutputPath}`, "RelationshipTypeGenerator");
+    const indexContent = this.buildIndexFileContent();
+    const indexPath = path2.join(this.options.outputDir, "index.ts");
+    await FileUtils.writeFileContent(indexPath, indexContent);
+    Logger.verbose(`Generated ${indexPath}`, "RelationshipTypeGenerator");
+  }
+  /**
+   * Generate separate files for each model
+   */
+  async generatePerModelFiles() {
+    for (const model of this.models) {
+      const imports = this.generateImportsForModel(model);
+      const declaration = Object.keys(model.relationships).length > 0 ? this.generateDeclarationForModel(model) : this.generateEmptyDeclaration(model);
+      const content = this.buildFileContent(imports, [declaration]);
+      const outputPath = path2.join(
+        this.options.outputDir,
+        `${model.className}.relationships.d.ts`
+      );
+      await FileUtils.writeFileContent(outputPath, content);
+      Logger.verbose(`Generated ${outputPath}`, "RelationshipTypeGenerator");
+    }
+  }
+  /**
+   * Generate import statements for all models and utility types
+   */
+  generateImports() {
+    const imports = [];
+    const hasRelationships = this.models.some(
+      (model) => Object.keys(model.relationships).length > 0
+    );
+    if (!hasRelationships) {
+      return imports;
+    }
+    const isConsumerProject = this.isConsumerProject();
+    const utilityTypesImport = isConsumerProject ? "import type { PaginationOptions, PaginatedResult } from 'js-bao';" : "import type { PaginationOptions, PaginatedResult } from '../types/relationshipMethods';";
+    imports.push(utilityTypesImport);
+    const usedModels = /* @__PURE__ */ new Set();
+    for (const model of this.models) {
+      if (Object.keys(model.relationships).length > 0) {
+        usedModels.add(model.className);
+        for (const config of Object.values(model.relationships)) {
+          const relatedModel = this.modelsByName.get(config.model);
+          if (relatedModel) {
+            usedModels.add(relatedModel.className);
+          }
+        }
+      }
+    }
+    for (const className of usedModels) {
+      const model = this.models.find((m) => m.className === className);
+      if (model) {
+        const relativePath = FileUtils.getRelativePath(
+          path2.join(this.options.outputDir, "relationships.d.ts"),
+          model.filePath
+        );
+        imports.push(`import { ${model.className} } from '${relativePath}';`);
+      }
+    }
+    return imports;
+  }
+  /**
+   * Generate imports for a specific model
+   */
+  generateImportsForModel(model) {
+    const imports = [];
+    const outputPath = path2.join(
+      this.options.outputDir,
+      `${model.className}.relationships.d.ts`
+    );
+    const isConsumerProject = this.isConsumerProject();
+    const utilityTypesImport = isConsumerProject ? "import type { PaginationOptions, PaginatedResult } from 'js-bao';" : `import type { PaginationOptions, PaginatedResult } from '${FileUtils.getRelativePath(
+      outputPath,
+      path2.join("src", "types", "relationshipMethods.ts")
+    )}';`;
+    imports.push(utilityTypesImport);
+    const relatedModelNames = /* @__PURE__ */ new Set();
+    for (const config of Object.values(model.relationships)) {
+      relatedModelNames.add(config.model);
+    }
+    for (const relatedModelName of relatedModelNames) {
+      const relatedModel = this.modelsByName.get(relatedModelName);
+      if (relatedModel && relatedModel !== model) {
+        const relativePath = FileUtils.getRelativePath(
+          outputPath,
+          relatedModel.filePath
+        );
+        imports.push(
+          `import { ${relatedModel.className} } from '${relativePath}';`
+        );
+      }
+    }
+    return imports;
+  }
+  /**
+   * Generate all model declarations
+   */
+  generateAllDeclarations() {
+    return this.models.filter((model) => Object.keys(model.relationships).length > 0).map((model) => this.generateDeclarationForModel(model));
+  }
+  /**
+   * Generate declaration for a specific model
+   */
+  generateDeclarationForModel(model) {
+    const relativePath = FileUtils.getRelativePath(
+      path2.join(this.options.outputDir, "relationships.d.ts"),
+      model.filePath
+    );
+    const methods = [];
+    for (const [relationshipName, config] of Object.entries(
+      model.relationships
+    )) {
+      const relatedModel = this.modelsByName.get(config.model);
+      if (!relatedModel) {
+        console.warn(
+          `[RelationshipTypeGenerator] Related model '${config.model}' not found for relationship '${relationshipName}' in model '${model.className}'`
+        );
+        continue;
+      }
+      switch (config.type) {
+        case "refersTo":
+          methods.push(
+            this.generateRefersToMethod(relationshipName, relatedModel)
+          );
+          break;
+        case "hasMany":
+          methods.push(
+            this.generateHasManyMethod(relationshipName, relatedModel)
+          );
+          break;
+        case "hasManyThrough":
+          methods.push(
+            ...this.generateHasManyThroughMethods(
+              relationshipName,
+              config,
+              relatedModel
+            )
+          );
+          break;
+        default:
+          console.warn(
+            `[RelationshipTypeGenerator] Unknown relationship type '${config.type}' for '${relationshipName}' in model '${model.className}'`
+          );
+      }
+    }
+    if (methods.length === 0) return "";
+    return `declare module '${relativePath}' {
+  interface ${model.className} {
+${methods.map((method) => `    ${method}`).join("\n")}
+  }
+}`;
+  }
+  generateEmptyDeclaration(model) {
+    return [`// ${model.className} has no relationships.`, "export {};"].join(
+      "\n"
+    );
+  }
+  /**
+   * Generate method signature for refersTo relationship
+   */
+  generateRefersToMethod(relationshipName, relatedModel) {
+    return `${relationshipName}(): Promise<${relatedModel.className} | null>;`;
+  }
+  /**
+   * Generate method signature for hasMany relationship
+   */
+  generateHasManyMethod(relationshipName, relatedModel) {
+    return `${relationshipName}(options?: PaginationOptions): Promise<PaginatedResult<${relatedModel.className}>>;`;
+  }
+  /**
+   * Generate method signatures for hasManyThrough relationship
+   */
+  generateHasManyThroughMethods(relationshipName, config, relatedModel) {
+    const methods = [];
+    methods.push(
+      `${relationshipName}(options?: PaginationOptions): Promise<PaginatedResult<${relatedModel.className}>>;`
+    );
+    const singularName = this.getSingularName(config.model);
+    const capitalizedSingular = singularName.charAt(0).toUpperCase() + singularName.slice(1);
+    methods.push(
+      `add${capitalizedSingular}(target: ${relatedModel.className} | string): Promise<void>;`
+    );
+    methods.push(
+      `remove${capitalizedSingular}(target: ${relatedModel.className} | string): Promise<void>;`
+    );
+    return methods;
+  }
+  /**
+   * Get singular form of a model name (simple implementation)
+   */
+  getSingularName(modelName) {
+    if (modelName.endsWith("s")) {
+      return modelName.slice(0, -1);
+    }
+    return modelName;
+  }
+  /**
+   * Build the final file content
+   */
+  buildFileContent(imports, declarations) {
+    const header = [
+      "// AUTO-GENERATED FILE - DO NOT EDIT",
+      "// This file was generated by js-bao-codegen",
+      "// Run `npx js-bao-codegen` to regenerate",
+      ""
+    ];
+    const content = [
+      ...header,
+      ...imports,
+      "",
+      ...declarations.filter((d) => d.length > 0),
+      ""
+    ];
+    return content.join("\n");
+  }
+  /**
+   * Build module file content (.ts file for better resolution)
+   */
+  buildModuleFileContent(imports, declarations) {
+    const header = [
+      "// AUTO-GENERATED FILE - DO NOT EDIT",
+      "// This file was generated by js-bao-codegen",
+      "// Run `npx js-bao-codegen` to regenerate",
+      ""
+    ];
+    const content = [
+      ...header,
+      ...imports,
+      "",
+      ...declarations.filter((d) => d.length > 0),
+      "",
+      "// Empty export to make this a module",
+      "export {};"
+    ];
+    return content.join("\n");
+  }
+  /**
+   * Build index file content for easier importing
+   */
+  buildIndexFileContent() {
+    return [
+      "// AUTO-GENERATED FILE - DO NOT EDIT",
+      "// This file was generated by js-bao-codegen",
+      "// Run `npx js-bao-codegen` to regenerate",
+      "",
+      "// Import relationship types to enable declaration merging",
+      "import './relationships';",
+      "",
+      "// Empty export to make this a module",
+      "export {};"
+    ].join("\n");
+  }
+  /**
+   * Update every model file with the new auto-generated header/footer blocks
+   */
+  async updateModelTemplates() {
+    for (const model of this.models) {
+      try {
+        await this.applyAutoBlocksToModel(model);
+      } catch (error) {
+        Logger.warn(
+          `Failed to update model file ${model.filePath}: ${error}`,
+          "RelationshipTypeGenerator"
+        );
+      }
+    }
+  }
+  async applyAutoBlocksToModel(model) {
+    if (!model.schemaIdentifier) {
+      Logger.warn(
+        `Skipping ${model.className}: could not determine schema identifier.`,
+        "RelationshipTypeGenerator"
+      );
+      return;
+    }
+    if (!await FileUtils.fileExists(model.filePath)) {
+      Logger.warn(
+        `Model file ${model.filePath} does not exist. Skipping.`,
+        "RelationshipTypeGenerator"
+      );
+      return;
+    }
+    let content = await FileUtils.readFileContent(model.filePath);
+    const originalContent = content;
+    content = this.stripLegacyRelationshipImports(content, model.className);
+    content = this.removeBlock(content, AUTO_HEADER_START, AUTO_HEADER_END);
+    content = this.removeBlock(content, LEGACY_HEADER_START, LEGACY_HEADER_END);
+    const headerBlock = this.buildAutoHeaderBlock(model);
+    const headerInsertIndex = this.findSchemaDeclarationEnd(
+      content,
+      model.schemaIdentifier
+    );
+    content = this.insertBlock(
+      content,
+      headerInsertIndex,
+      headerBlock
+    );
+    content = this.ensureClassDeclaration(content, model.className);
+    content = this.removeBlock(content, AUTO_FOOTER_START, AUTO_FOOTER_END);
+    content = this.removeBlock(content, LEGACY_FOOTER_START, LEGACY_FOOTER_END);
+    const footerBlock = this.buildAutoFooterBlock(model);
+    content = this.insertBlock(content, content.length, footerBlock);
+    content = this.normalizeWhitespace(content);
+    if (content !== originalContent) {
+      if (!content.endsWith("\n")) {
+        content += "\n";
+      }
+      await FileUtils.writeFileContent(model.filePath, content);
+      Logger.verbose(
+        `Updated auto-generation blocks in ${model.filePath}`,
+        "RelationshipTypeGenerator"
+      );
+    }
+  }
+  buildAutoHeaderBlock(model) {
+    const lines = [
+      "",
+      AUTO_HEADER_START,
+      "/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */",
+      'import type { InferAttrs } from "js-bao";',
+      'import { attachAndRegisterModel } from "js-bao";',
+      "",
+      `export type ${model.className}Attrs = InferAttrs<typeof ${model.schemaIdentifier}>;`,
+      `export interface ${model.className} extends ${model.className}Attrs, BaseModel {}`,
+      AUTO_HEADER_END,
+      ""
+    ];
+    return lines.join("\n");
+  }
+  buildAutoFooterBlock(model) {
+    const lines = ["", AUTO_FOOTER_START];
+    if (Object.keys(model.relationships).length > 0) {
+      lines.push(
+        `import "./generated/${model.className}.relationships.d";`,
+        ""
+      );
+    }
+    lines.push(
+      `attachAndRegisterModel(${model.className}, ${model.schemaIdentifier});`,
+      AUTO_FOOTER_END,
+      ""
+    );
+    return lines.join("\n");
+  }
+  removeBlock(content, startMarker, endMarker) {
+    const markerRegex = new RegExp(
+      `${this.escapeRegExp(startMarker)}[\\s\\S]*?${this.escapeRegExp(
+        endMarker
+      )}`,
+      "m"
+    );
+    let updated = content;
+    while (markerRegex.test(updated)) {
+      updated = updated.replace(markerRegex, "");
+    }
+    return updated;
+  }
+  insertBlock(content, insertionIndex, blockContent) {
+    const index = insertionIndex >= 0 && insertionIndex <= content.length ? insertionIndex : content.length;
+    if (index === 0) {
+      return `${blockContent}${content}`;
+    }
+    return `${content.slice(0, index)}${blockContent}${content.slice(index)}`;
+  }
+  findSchemaDeclarationEnd(content, schemaIdentifier) {
+    const pattern = new RegExp(
+      `const\\s+${schemaIdentifier}\\s*=\\s*defineModelSchema\\s*\\(`,
+      "m"
+    );
+    const match = pattern.exec(content);
+    if (!match) {
+      return -1;
+    }
+    let depth = 0;
+    const start = content.indexOf("(", match.index);
+    if (start === -1) {
+      return -1;
+    }
+    for (let i = start; i < content.length; i++) {
+      const char = content[i];
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth--;
+        if (depth === 0) {
+          const semicolonIndex = content.indexOf(";", i);
+          return semicolonIndex === -1 ? i + 1 : semicolonIndex + 1;
+        }
+      }
+    }
+    return -1;
+  }
+  escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  stripLegacyRelationshipImports(content, className) {
+    const patterns = [
+      /\s*\/\/\s*Auto-generated relationship types\s*/g,
+      new RegExp(
+        `\\s*import\\s+['"]\\.\\/?[^'"]*${className}\\.relationships\\.d(\\.ts)?['"]\\s*;?`,
+        "g"
+      ),
+      /\s*import\s+['"]\.[^'"]*\.relationships\.d(\.ts)?['"]\s*;?/g
+    ];
+    let updated = content;
+    for (const pattern of patterns) {
+      updated = updated.replace(pattern, "\n");
+    }
+    return updated;
+  }
+  ensureClassDeclaration(content, className) {
+    const classRegex = new RegExp(`export\\s+class\\s+${className}\\b`);
+    if (classRegex.test(content)) {
+      return content;
+    }
+    const stub = [
+      "",
+      `export class ${className} extends BaseModel {`,
+      "}",
+      ""
+    ].join("\n");
+    const footerIndex = content.indexOf(AUTO_FOOTER_START);
+    const insertionIndex = footerIndex === -1 ? content.length : footerIndex;
+    return `${content.slice(0, insertionIndex)}${stub}${content.slice(
+      insertionIndex
+    )}`;
+  }
+  normalizeWhitespace(content) {
+    return content.replace(/\n{3,}/g, "\n\n");
+  }
+};
+
+// package.json
+var package_default = {
+  name: "js-bao",
+  version: "0.2.8",
+  description: "A library providing data modeling capabilities which support live updates and queries.",
+  types: "dist/index.d.ts",
+  type: "module",
+  files: [
+    "dist"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      node: {
+        import: "./dist/node.js",
+        require: "./dist/node.cjs"
+      },
+      browser: {
+        import: "./dist/browser.js",
+        require: "./dist/browser.cjs"
+      },
+      default: {
+        import: "./dist/index.js",
+        require: "./dist/index.cjs"
+      }
+    },
+    "./node": {
+      types: "./dist/node.d.ts",
+      import: "./dist/node.js",
+      require: "./dist/node.cjs"
+    },
+    "./browser": {
+      types: "./dist/browser.d.ts",
+      import: "./dist/browser.js",
+      require: "./dist/browser.cjs"
+    }
+  },
+  bin: {
+    "js-bao-codegen": "./dist/codegen.cjs",
+    "jsbao-codegen": "./dist/codegen.cjs"
+  },
+  scripts: {
+    build: "npm run build:cli && npm run codegen && rm -f dist/index.* dist/node.* dist/browser.* && npm run build:main",
+    "build:main": "npm run build:browser && npm run build:node && npm run build:universal",
+    "build:browser": "tsup src/browser.ts --format esm,cjs --dts --platform browser --external better-sqlite3 --external sql.js --external async-mutex --external ulid --no-splitting",
+    "build:node": "tsup src/node.ts --format esm,cjs --dts --platform node --external better-sqlite3 --external sql.js --external async-mutex --external ulid --no-splitting",
+    "build:universal": "tsup src/index.ts --format esm,cjs --dts --external better-sqlite3 --external sql.js --external async-mutex --external ulid --no-splitting",
+    "build:cli": "tsup src/cli/codegen.ts --format cjs --dts --platform node --target node18 --external commander --external typescript --external fs --external path --external util --no-splitting",
+    dev: 'npm run build:cli && concurrently "npm run codegen:watch" "npm run dev:main"',
+    "dev:main": 'concurrently "npm run build:browser:dev --watch" "npm run build:node:dev --watch" "npm run build:universal:dev --watch"',
+    "dev:simple": "npm run build:cli && npm run codegen && npm run build:main --watch",
+    "build:browser:dev": "tsup src/browser.ts --format esm,cjs --dts --sourcemap --platform browser --external better-sqlite3 --external sql.js --external async-mutex --external ulid",
+    "build:node:dev": "tsup src/node.ts --format esm,cjs --dts --sourcemap --platform node --external better-sqlite3 --external sql.js --external async-mutex --external ulid",
+    "build:universal:dev": "tsup src/index.ts --format esm,cjs --dts --sourcemap --external better-sqlite3 --external sql.js --external async-mutex --external ulid",
+    codegen: "./dist/codegen.cjs --config js-bao.config.cjs || echo 'Codegen skipped (likely in consumer project)'",
+    "codegen:watch": "./dist/codegen.cjs --config js-bao.config.cjs --watch",
+    "codegen:consumer": `node -e "require('child_process').spawn('./node_modules/.bin/js-bao-codegen', process.argv.slice(2), {stdio: 'inherit'})"`,
+    test: 'echo "Error: no test specified" && exit 1',
+    prepare: "npm run build",
+    prepublishOnly: "npm run build"
+  },
+  dependencies: {
+    "async-mutex": "^0.5.0",
+    "sql.js": "^1.13.0",
+    ulid: "^3.0.0"
+  },
+  devDependencies: {
+    "@types/better-sqlite3": "^7.6.9",
+    "@types/node": "^20.17.51",
+    "@types/sql.js": "^1.4.9",
+    commander: "^11.0.0",
+    concurrently: "^9.1.2",
+    tsup: "^8.0.2",
+    tsx: "^4.19.4",
+    typescript: "^5.4.5",
+    yjs: "^13.6.18"
+  },
+  peerDependencies: {
+    yjs: "^13.6.18"
+  },
+  optionalDependencies: {
+    "better-sqlite3": "^9.6.0"
+  },
+  keywords: [
+    "yjs",
+    "crdt",
+    "orm",
+    "sqljs",
+    "database",
+    "reactivedb",
+    "nodejs",
+    "browser",
+    "sqlite"
+  ],
+  author: "Primitive LLC",
+  license: "UNLICENSED"
+};
+
+// src/cli/codegen.ts
+var CodegenCLI = class {
+  program;
+  constructor() {
+    this.program = new import_commander.Command();
+    this.setupCommands();
+  }
+  setupCommands() {
+    this.program.name("js-bao-codegen").description(
+      "Auto-generate TypeScript declarations for js-bao relationship methods"
+    ).version("1.0.0");
+    this.program.option(
+      "-i, --input <dir>",
+      "Input directory containing model files",
+      "./src/models"
+    ).option(
+      "-o, --output <dir>",
+      "Output directory for generated files",
+      "./src/models/generated"
+    ).option("-c, --config <file>", "Path to configuration file").option("-w, --watch", "Watch for changes and regenerate", false).option("--exclude <patterns...>", "Exclude patterns (glob)", [
+      "**/*.test.ts",
+      "**/*.spec.ts"
+    ]).option(
+      "--generate-per-model-files",
+      "Generate separate files for each model",
+      false
+    ).option(
+      "--no-include-pagination",
+      "Exclude pagination types from output",
+      false
+    ).option("-v, --verbose", "Show detailed logging information", false).action(async (options) => {
+      await this.run(options);
+    });
+  }
+  async run(cliOptions) {
+    try {
+      Logger.log(
+        `js-bao-codegen v${package_default.version ?? "unknown"}`,
+        "js-bao-codegen"
+      );
+      Logger.setVerbose(cliOptions.verbose);
+      Logger.verbose(
+        "Starting TypeScript relationship declaration generation...",
+        "js-bao-codegen"
+      );
+      const config = await this.loadConfig(cliOptions);
+      Logger.verbose("Configuration:", "js-bao-codegen");
+      if (cliOptions.verbose) {
+        console.log(config);
+      }
+      const excludePatternsWithOutput = [
+        ...config.exclude,
+        `**/${path3.relative(config.input, config.output)}/**`,
+        `${path3.relative(config.input, config.output)}/**`
+      ];
+      const resolvedInputDir = path3.resolve(config.input);
+      Logger.log(
+        `Scanning for model files in ${resolvedInputDir}`,
+        "js-bao-codegen"
+      );
+      Logger.verbose(
+        `Exclude patterns: ${excludePatternsWithOutput.join(", ")}`,
+        "js-bao-codegen"
+      );
+      const modelFiles = await this.findModelFiles(
+        config.input,
+        excludePatternsWithOutput
+      );
+      const formattedList = modelFiles.length > 0 ? modelFiles.map((file) => ` - ${file}`).join("\n") : " (none)";
+      Logger.log(
+        `Found ${modelFiles.length} model file(s):
+${formattedList}`,
+        "js-bao-codegen"
+      );
+      if (modelFiles.length === 0) {
+        Logger.warn("No model files found. Exiting.", "js-bao-codegen");
+        return;
+      }
+      const analyzer = new ModelAnalyzer(modelFiles, cliOptions.verbose);
+      const models = await analyzer.analyzeModels();
+      Logger.verbose(
+        `Analyzed ${models.length} models with relationships`,
+        "js-bao-codegen"
+      );
+      if (models.length === 0) {
+        Logger.warn(
+          "No models with relationships found. Exiting.",
+          "js-bao-codegen"
+        );
+        return;
+      }
+      const generationOptions = {
+        outputDir: config.output,
+        modelsDir: config.input,
+        generatePerModelFiles: config.generatePerModelFiles,
+        includePagination: config.includePagination
+      };
+      const generator = new RelationshipTypeGenerator(
+        models,
+        generationOptions
+      );
+      await generator.generateTypeDeclarations();
+      Logger.log("Generation completed successfully!", "js-bao-codegen");
+      if (config.watch) {
+        await this.setupWatchMode(config, modelFiles);
+      }
+    } catch (error) {
+      Logger.error("Error: " + error, "js-bao-codegen");
+      process.exit(1);
+    }
+  }
+  async loadConfig(cliOptions) {
+    let config = { ...cliOptions };
+    if (cliOptions.config) {
+      try {
+        const configPath = path3.resolve(cliOptions.config);
+        const configExists = await FileUtils.fileExists(configPath);
+        if (configExists) {
+          const configContent = await FileUtils.readFileContent(configPath);
+          let configFile;
+          if (configPath.endsWith(".json")) {
+            configFile = JSON.parse(configContent);
+          } else {
+            delete require.cache[require.resolve(configPath)];
+            configFile = require(configPath);
+          }
+          config = {
+            input: cliOptions.input !== "./src/models" ? cliOptions.input : configFile.modelsDir || "./src/models",
+            output: cliOptions.output !== "./src/models/generated" ? cliOptions.output : configFile.outputDir || "./src/models/generated",
+            config: cliOptions.config,
+            watch: cliOptions.watch,
+            exclude: cliOptions.exclude.length > 2 ? cliOptions.exclude : configFile.exclude || ["**/*.test.ts", "**/*.spec.ts"],
+            generatePerModelFiles: cliOptions.generatePerModelFiles || configFile.generatePerModelFiles || false,
+            includePagination: configFile.includePagination ?? true,
+            verbose: cliOptions.verbose
+          };
+        } else {
+          Logger.warn(`Config file not found: ${configPath}`, "js-bao-codegen");
+        }
+      } catch (error) {
+        Logger.error(`Error loading config file: ${error}`, "js-bao-codegen");
+        throw error;
+      }
+    }
+    return config;
+  }
+  async findModelFiles(inputDir, exclude) {
+    const resolvedInputDir = path3.resolve(inputDir);
+    return await FileUtils.findTSFiles(resolvedInputDir, exclude);
+  }
+  async setupWatchMode(config, initialFiles) {
+    Logger.log("Watch mode enabled. Watching for changes...", "js-bao-codegen");
+    const checkInterval = 2e3;
+    let lastModified = /* @__PURE__ */ new Map();
+    for (const file of initialFiles) {
+      try {
+        const stats = await import("fs/promises").then((fs2) => fs2.stat(file));
+        lastModified.set(file, stats.mtimeMs);
+      } catch (error) {
+        Logger.warn(`Could not stat file ${file}: ${error}`, "js-bao-codegen");
+      }
+    }
+    const poll = async () => {
+      try {
+        let hasChanges = false;
+        for (const file of initialFiles) {
+          try {
+            const stats = await import("fs/promises").then(
+              (fs2) => fs2.stat(file)
+            );
+            const lastMod = lastModified.get(file) || 0;
+            if (stats.mtimeMs > lastMod) {
+              Logger.log(`Detected change in ${file}`, "js-bao-codegen");
+              lastModified.set(file, stats.mtimeMs);
+              hasChanges = true;
+            }
+          } catch (error) {
+            if (lastModified.has(file)) {
+              Logger.log(`File deleted: ${file}`, "js-bao-codegen");
+              lastModified.delete(file);
+              hasChanges = true;
+            }
+          }
+        }
+        const excludePatternsWithOutput = [
+          ...config.exclude,
+          `**/${path3.relative(config.input, config.output)}/**`,
+          `${path3.relative(config.input, config.output)}/**`
+        ];
+        const currentFiles = await this.findModelFiles(
+          config.input,
+          excludePatternsWithOutput
+        );
+        const newFiles = currentFiles.filter((f) => !lastModified.has(f));
+        if (newFiles.length > 0) {
+          Logger.log(`Detected ${newFiles.length} new files`, "js-bao-codegen");
+          for (const file of newFiles) {
+            const stats = await import("fs/promises").then(
+              (fs2) => fs2.stat(file)
+            );
+            lastModified.set(file, stats.mtimeMs);
+          }
+          hasChanges = true;
+        }
+        if (hasChanges) {
+          Logger.log("Regenerating types...", "js-bao-codegen");
+          await this.run({ ...config, watch: false });
+        }
+      } catch (error) {
+        Logger.error("Error in watch mode: " + error, "js-bao-codegen");
+      }
+      setTimeout(poll, checkInterval);
+    };
+    setTimeout(poll, checkInterval);
+  }
+  execute() {
+    this.program.parse(process.argv);
+  }
+};
+var cli = new CodegenCLI();
+cli.execute();