drizzle-docs-generator 0.1.0

package/dist/parser/index.d.ts

@@ -0,0 +1,5 @@
+export { extractComments } from './comments';
+export type { SchemaComments, TableComment, ColumnComment } from './comments';
+export { extractRelations } from './relations';
+export type { ParsedRelation, SchemaRelations } from './relations';
+//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC"}

package/dist/parser/relations.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parsed relation from relations() definition
+ */
+export interface ParsedRelation {
+    /** Name of the source table (the first argument of relations()) */
+    sourceTable: string;
+    /** Name of the target table (the first argument of one()/many()) */
+    targetTable: string;
+    /** Relation type: "one" or "many" */
+    type: "one" | "many";
+    /** Source column names (from fields array) */
+    fields: string[];
+    /** Target column names (from references array) */
+    references: string[];
+}
+/**
+ * All extracted relations from a schema file
+ */
+export interface SchemaRelations {
+    relations: ParsedRelation[];
+}
+/**
+ * Extract relations from a Drizzle schema source file or directory using AST parsing
+ *
+ * Parses TypeScript source files and extracts:
+ * - relations() function calls
+ * - one() and many() relation definitions within them
+ * - fields and references arrays for generating DBML Refs
+ *
+ * @param sourcePath - Path to the TypeScript schema file or directory
+ * @returns Extracted relations
+ */
+export declare function extractRelations(sourcePath: string): SchemaRelations;
+//# sourceMappingURL=relations.d.ts.map

package/dist/parser/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../src/parser/relations.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,mEAAmE;IACnE,WAAW,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,8CAA8C;IAC9C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,kDAAkD;IAClD,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,cAAc,EAAE,CAAC;CAC7B;AA+BD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAapE"}

package/dist/parser/relations.js

@@ -0,0 +1,111 @@
+import * as r from "typescript";
+import { readFileSync as h, statSync as A, readdirSync as b } from "node:fs";
+import { join as F } from "node:path";
+function d(e) {
+  const s = A(e);
+  if (s.isFile())
+    return e.endsWith(".ts") ? [e] : [];
+  if (s.isDirectory()) {
+    const n = [], i = b(e, { withFileTypes: !0 });
+    for (const t of i) {
+      const o = F(e, t.name);
+      t.isDirectory() ? n.push(...d(o)) : t.isFile() && t.name.endsWith(".ts") && !t.name.endsWith(".test.ts") && n.push(o);
+    }
+    return n;
+  }
+  return [];
+}
+function S(e) {
+  const s = { relations: [] }, n = d(e);
+  for (const i of n) {
+    const t = h(i, "utf-8"), o = r.createSourceFile(i, t, r.ScriptTarget.Latest, !0);
+    x(o, o, s);
+  }
+  return s;
+}
+function x(e, s, n) {
+  if (r.isVariableStatement(e)) {
+    for (const i of e.declarationList.declarations)
+      if (i.initializer && r.isCallExpression(i.initializer)) {
+        const t = p(i.initializer);
+        t && n.relations.push(...t);
+      }
+  }
+  if (r.isExportAssignment(e) && r.isCallExpression(e.expression)) {
+    const i = p(e.expression);
+    i && n.relations.push(...i);
+  }
+  r.forEachChild(e, (i) => x(i, s, n));
+}
+function p(e, s) {
+  if (y(e) !== "relations")
+    return;
+  const i = e.arguments[0];
+  if (!i)
+    return;
+  const t = g(i);
+  if (!t)
+    return;
+  const o = e.arguments[1];
+  if (!(!o || !r.isArrowFunction(o)))
+    return v(t, o);
+}
+function v(e, s, n) {
+  const i = [];
+  let t = s.body;
+  if (r.isParenthesizedExpression(t) && (t = t.expression), !r.isObjectLiteralExpression(t))
+    return i;
+  for (const o of t.properties)
+    if (r.isPropertyAssignment(o) && r.isCallExpression(o.initializer)) {
+      const f = z(e, o.initializer);
+      f && i.push(f);
+    }
+  return i;
+}
+function z(e, s, n) {
+  const i = y(s);
+  if (i !== "one" && i !== "many")
+    return;
+  const t = s.arguments[0];
+  if (!t)
+    return;
+  const o = g(t);
+  if (!o)
+    return;
+  const f = s.arguments[1];
+  let c = [], l = [];
+  if (f && r.isObjectLiteralExpression(f)) {
+    for (const a of f.properties)
+      if (r.isPropertyAssignment(a) && r.isIdentifier(a.name)) {
+        const u = a.name.text;
+        u === "fields" && r.isArrayLiteralExpression(a.initializer) ? c = m(a.initializer) : u === "references" && r.isArrayLiteralExpression(a.initializer) && (l = m(a.initializer));
+      }
+  }
+  return {
+    sourceTable: e,
+    targetTable: o,
+    type: i,
+    fields: c,
+    references: l
+  };
+}
+function m(e) {
+  const s = [];
+  for (const n of e.elements)
+    r.isPropertyAccessExpression(n) ? s.push(n.name.text) : r.isIdentifier(n) && s.push(n.text);
+  return s;
+}
+function y(e) {
+  if (r.isIdentifier(e.expression))
+    return e.expression.text;
+  if (r.isPropertyAccessExpression(e.expression))
+    return e.expression.name.text;
+}
+function g(e) {
+  if (r.isIdentifier(e))
+    return e.text;
+}
+export {
+  S as extractRelations
+};
+//# sourceMappingURL=relations.js.map

package/dist/parser/relations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.js","sources":["../../src/parser/relations.ts"],"sourcesContent":["import * as ts from \"typescript\";\nimport { readFileSync, statSync, readdirSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\n/**\n * Parsed relation from relations() definition\n */\nexport interface ParsedRelation {\n  /** Name of the source table (the first argument of relations()) */\n  sourceTable: string;\n  /** Name of the target table (the first argument of one()/many()) */\n  targetTable: string;\n  /** Relation type: \"one\" or \"many\" */\n  type: \"one\" | \"many\";\n  /** Source column names (from fields array) */\n  fields: string[];\n  /** Target column names (from references array) */\n  references: string[];\n}\n\n/**\n * All extracted relations from a schema file\n */\nexport interface SchemaRelations {\n  relations: ParsedRelation[];\n}\n\n/**\n * Get all TypeScript files from a path (file or directory)\n */\nfunction getTypeScriptFiles(sourcePath: string): string[] {\n  const stat = statSync(sourcePath);\n\n  if (stat.isFile()) {\n    return sourcePath.endsWith(\".ts\") ? [sourcePath] : [];\n  }\n\n  if (stat.isDirectory()) {\n    const files: string[] = [];\n    const entries = readdirSync(sourcePath, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = join(sourcePath, entry.name);\n      if (entry.isDirectory()) {\n        files.push(...getTypeScriptFiles(fullPath));\n      } else if (entry.isFile() && entry.name.endsWith(\".ts\") && !entry.name.endsWith(\".test.ts\")) {\n        files.push(fullPath);\n      }\n    }\n\n    return files;\n  }\n\n  return [];\n}\n\n/**\n * Extract relations from a Drizzle schema source file or directory using AST parsing\n *\n * Parses TypeScript source files and extracts:\n * - relations() function calls\n * - one() and many() relation definitions within them\n * - fields and references arrays for generating DBML Refs\n *\n * @param sourcePath - Path to the TypeScript schema file or directory\n * @returns Extracted relations\n */\nexport function extractRelations(sourcePath: string): SchemaRelations {\n  const result: SchemaRelations = { relations: [] };\n  const files = getTypeScriptFiles(sourcePath);\n\n  for (const filePath of files) {\n    const sourceCode = readFileSync(filePath, \"utf-8\");\n    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);\n\n    // Visit all nodes to find relations() calls\n    visitNode(sourceFile, sourceFile, result);\n  }\n\n  return result;\n}\n\n/**\n * Recursively visit AST nodes to find relations() definitions\n */\nfunction visitNode(node: ts.Node, sourceFile: ts.SourceFile, result: SchemaRelations): void {\n  // Look for variable declarations that define relations\n  if (ts.isVariableStatement(node)) {\n    for (const declaration of node.declarationList.declarations) {\n      if (declaration.initializer && ts.isCallExpression(declaration.initializer)) {\n        const parsedRelations = parseRelationsDefinition(declaration.initializer, sourceFile);\n        if (parsedRelations) {\n          result.relations.push(...parsedRelations);\n        }\n      }\n    }\n  }\n\n  // Also check for direct call expressions (e.g., export const x = relations(...))\n  if (ts.isExportAssignment(node) && ts.isCallExpression(node.expression)) {\n    const parsedRelations = parseRelationsDefinition(node.expression, sourceFile);\n    if (parsedRelations) {\n      result.relations.push(...parsedRelations);\n    }\n  }\n\n  ts.forEachChild(node, (child) => visitNode(child, sourceFile, result));\n}\n\n/**\n * Parse a relations() call expression\n *\n * Example:\n * relations(posts, ({ one }) => ({\n *   author: one(users, {\n *     fields: [posts.authorId],\n *     references: [users.id],\n *   }),\n * }))\n */\nfunction parseRelationsDefinition(\n  callExpr: ts.CallExpression,\n  sourceFile: ts.SourceFile,\n): ParsedRelation[] | undefined {\n  const funcName = getCallExpressionName(callExpr);\n\n  if (funcName !== \"relations\") {\n    return undefined;\n  }\n\n  // Get source table from first argument\n  const sourceTableArg = callExpr.arguments[0];\n  if (!sourceTableArg) {\n    return undefined;\n  }\n  const sourceTable = extractIdentifierName(sourceTableArg);\n  if (!sourceTable) {\n    return undefined;\n  }\n\n  // Get the callback function (second argument)\n  const callbackArg = callExpr.arguments[1];\n  if (!callbackArg || !ts.isArrowFunction(callbackArg)) {\n    return undefined;\n  }\n\n  // Parse the callback body for one()/many() calls\n  return parseRelationsCallback(sourceTable, callbackArg, sourceFile);\n}\n\n/**\n * Parse the callback function inside relations()\n */\nfunction parseRelationsCallback(\n  sourceTable: string,\n  callback: ts.ArrowFunction,\n  sourceFile: ts.SourceFile,\n): ParsedRelation[] {\n  const relations: ParsedRelation[] = [];\n\n  // The callback body should be an object literal or parenthesized expression containing object literal\n  let body = callback.body;\n\n  // Unwrap parenthesized expression: ({ ... })\n  if (ts.isParenthesizedExpression(body)) {\n    body = body.expression;\n  }\n\n  if (!ts.isObjectLiteralExpression(body)) {\n    return relations;\n  }\n\n  // Iterate over object properties to find one()/many() calls\n  for (const property of body.properties) {\n    if (ts.isPropertyAssignment(property) && ts.isCallExpression(property.initializer)) {\n      const relation = parseRelationCall(sourceTable, property.initializer, sourceFile);\n      if (relation) {\n        relations.push(relation);\n      }\n    }\n  }\n\n  return relations;\n}\n\n/**\n * Parse a one() or many() call expression\n */\nfunction parseRelationCall(\n  sourceTable: string,\n  callExpr: ts.CallExpression,\n  _sourceFile: ts.SourceFile,\n): ParsedRelation | undefined {\n  const funcName = getCallExpressionName(callExpr);\n\n  if (funcName !== \"one\" && funcName !== \"many\") {\n    return undefined;\n  }\n\n  // Get target table from first argument\n  const targetTableArg = callExpr.arguments[0];\n  if (!targetTableArg) {\n    return undefined;\n  }\n  const targetTable = extractIdentifierName(targetTableArg);\n  if (!targetTable) {\n    return undefined;\n  }\n\n  // For many(), there might not be a config object (no fields/references)\n  // In that case, the relation is only useful if there's a corresponding one() on the other side\n  const configArg = callExpr.arguments[1];\n\n  let fields: string[] = [];\n  let references: string[] = [];\n\n  if (configArg && ts.isObjectLiteralExpression(configArg)) {\n    // Parse fields and references from config object\n    for (const property of configArg.properties) {\n      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {\n        const propName = property.name.text;\n\n        if (propName === \"fields\" && ts.isArrayLiteralExpression(property.initializer)) {\n          fields = extractColumnNames(property.initializer);\n        } else if (propName === \"references\" && ts.isArrayLiteralExpression(property.initializer)) {\n          references = extractColumnNames(property.initializer);\n        }\n      }\n    }\n  }\n\n  return {\n    sourceTable,\n    targetTable,\n    type: funcName,\n    fields,\n    references,\n  };\n}\n\n/**\n * Extract column names from an array literal like [posts.authorId, posts.title]\n */\nfunction extractColumnNames(arrayLiteral: ts.ArrayLiteralExpression): string[] {\n  const names: string[] = [];\n\n  for (const element of arrayLiteral.elements) {\n    // Handle property access like: posts.authorId\n    if (ts.isPropertyAccessExpression(element)) {\n      names.push(element.name.text);\n    }\n    // Handle identifier (less common)\n    else if (ts.isIdentifier(element)) {\n      names.push(element.text);\n    }\n  }\n\n  return names;\n}\n\n/**\n * Get the function name from a call expression\n */\nfunction getCallExpressionName(callExpr: ts.CallExpression): string | undefined {\n  if (ts.isIdentifier(callExpr.expression)) {\n    return callExpr.expression.text;\n  }\n  if (ts.isPropertyAccessExpression(callExpr.expression)) {\n    return callExpr.expression.name.text;\n  }\n  return undefined;\n}\n\n/**\n * Extract identifier name from an expression\n */\nfunction extractIdentifierName(expr: ts.Expression): string | undefined {\n  if (ts.isIdentifier(expr)) {\n    return expr.text;\n  }\n  return undefined;\n}\n"],"names":["getTypeScriptFiles","sourcePath","stat","statSync","files","entries","readdirSync","entry","fullPath","join","extractRelations","result","filePath","sourceCode","readFileSync","sourceFile","ts","visitNode","node","declaration","parsedRelations","parseRelationsDefinition","child","callExpr","getCallExpressionName","sourceTableArg","sourceTable","extractIdentifierName","callbackArg","parseRelationsCallback","callback","relations","body","property","relation","parseRelationCall","_sourceFile","funcName","targetTableArg","targetTable","configArg","fields","references","propName","extractColumnNames","arrayLiteral","names","element","expr"],"mappings":";;;AA8BA,SAASA,EAAmBC,GAA8B;AACxD,QAAMC,IAAOC,EAASF,CAAU;AAEhC,MAAIC,EAAK;AACP,WAAOD,EAAW,SAAS,KAAK,IAAI,CAACA,CAAU,IAAI,CAAA;AAGrD,MAAIC,EAAK,eAAe;AACtB,UAAME,IAAkB,CAAA,GAClBC,IAAUC,EAAYL,GAAY,EAAE,eAAe,IAAM;AAE/D,eAAWM,KAASF,GAAS;AAC3B,YAAMG,IAAWC,EAAKR,GAAYM,EAAM,IAAI;AAC5C,MAAIA,EAAM,gBACRH,EAAM,KAAK,GAAGJ,EAAmBQ,CAAQ,CAAC,IACjCD,EAAM,OAAA,KAAYA,EAAM,KAAK,SAAS,KAAK,KAAK,CAACA,EAAM,KAAK,SAAS,UAAU,KACxFH,EAAM,KAAKI,CAAQ;AAAA,IAEvB;AAEA,WAAOJ;AAAA,EACT;AAEA,SAAO,CAAA;AACT;AAaO,SAASM,EAAiBT,GAAqC;AACpE,QAAMU,IAA0B,EAAE,WAAW,GAAC,GACxCP,IAAQJ,EAAmBC,CAAU;AAE3C,aAAWW,KAAYR,GAAO;AAC5B,UAAMS,IAAaC,EAAaF,GAAU,OAAO,GAC3CG,IAAaC,EAAG,iBAAiBJ,GAAUC,GAAYG,EAAG,aAAa,QAAQ,EAAI;AAGzF,IAAAC,EAAUF,GAAYA,GAAYJ,CAAM;AAAA,EAC1C;AAEA,SAAOA;AACT;AAKA,SAASM,EAAUC,GAAeH,GAA2BJ,GAA+B;AAE1F,MAAIK,EAAG,oBAAoBE,CAAI;AAC7B,eAAWC,KAAeD,EAAK,gBAAgB;AAC7C,UAAIC,EAAY,eAAeH,EAAG,iBAAiBG,EAAY,WAAW,GAAG;AAC3E,cAAMC,IAAkBC,EAAyBF,EAAY,WAAuB;AACpF,QAAIC,KACFT,EAAO,UAAU,KAAK,GAAGS,CAAe;AAAA,MAE5C;AAAA;AAKJ,MAAIJ,EAAG,mBAAmBE,CAAI,KAAKF,EAAG,iBAAiBE,EAAK,UAAU,GAAG;AACvE,UAAME,IAAkBC,EAAyBH,EAAK,UAAsB;AAC5E,IAAIE,KACFT,EAAO,UAAU,KAAK,GAAGS,CAAe;AAAA,EAE5C;AAEA,EAAAJ,EAAG,aAAaE,GAAM,CAACI,MAAUL,EAAUK,GAAOP,GAAYJ,CAAM,CAAC;AACvE;AAaA,SAASU,EACPE,GACAR,GAC8B;AAG9B,MAFiBS,EAAsBD,CAAQ,MAE9B;AACf;AAIF,QAAME,IAAiBF,EAAS,UAAU,CAAC;AAC3C,MAAI,CAACE;AACH;AAEF,QAAMC,IAAcC,EAAsBF,CAAc;AACxD,MAAI,CAACC;AACH;AAIF,QAAME,IAAcL,EAAS,UAAU,CAAC;AACxC,MAAI,GAACK,KAAe,CAACZ,EAAG,gBAAgBY,CAAW;AAKnD,WAAOC,EAAuBH,GAAaE,CAAuB;AACpE;AAKA,SAASC,EACPH,GACAI,GACAf,GACkB;AAClB,QAAMgB,IAA8B,CAAA;AAGpC,MAAIC,IAAOF,EAAS;AAOpB,MAJId,EAAG,0BAA0BgB,CAAI,MACnCA,IAAOA,EAAK,aAGV,CAAChB,EAAG,0BAA0BgB,CAAI;AACpC,WAAOD;AAIT,aAAWE,KAAYD,EAAK;AAC1B,QAAIhB,EAAG,qBAAqBiB,CAAQ,KAAKjB,EAAG,iBAAiBiB,EAAS,WAAW,GAAG;AAClF,YAAMC,IAAWC,EAAkBT,GAAaO,EAAS,WAAuB;AAChF,MAAIC,KACFH,EAAU,KAAKG,CAAQ;AAAA,IAE3B;AAGF,SAAOH;AACT;AAKA,SAASI,EACPT,GACAH,GACAa,GAC4B;AAC5B,QAAMC,IAAWb,EAAsBD,CAAQ;AAE/C,MAAIc,MAAa,SAASA,MAAa;AACrC;AAIF,QAAMC,IAAiBf,EAAS,UAAU,CAAC;AAC3C,MAAI,CAACe;AACH;AAEF,QAAMC,IAAcZ,EAAsBW,CAAc;AACxD,MAAI,CAACC;AACH;AAKF,QAAMC,IAAYjB,EAAS,UAAU,CAAC;AAEtC,MAAIkB,IAAmB,CAAA,GACnBC,IAAuB,CAAA;AAE3B,MAAIF,KAAaxB,EAAG,0BAA0BwB,CAAS;AAErD,eAAWP,KAAYO,EAAU;AAC/B,UAAIxB,EAAG,qBAAqBiB,CAAQ,KAAKjB,EAAG,aAAaiB,EAAS,IAAI,GAAG;AACvE,cAAMU,IAAWV,EAAS,KAAK;AAE/B,QAAIU,MAAa,YAAY3B,EAAG,yBAAyBiB,EAAS,WAAW,IAC3EQ,IAASG,EAAmBX,EAAS,WAAW,IACvCU,MAAa,gBAAgB3B,EAAG,yBAAyBiB,EAAS,WAAW,MACtFS,IAAaE,EAAmBX,EAAS,WAAW;AAAA,MAExD;AAAA;AAIJ,SAAO;AAAA,IACL,aAAAP;AAAA,IACA,aAAAa;AAAA,IACA,MAAMF;AAAA,IACN,QAAAI;AAAA,IACA,YAAAC;AAAA,EAAA;AAEJ;AAKA,SAASE,EAAmBC,GAAmD;AAC7E,QAAMC,IAAkB,CAAA;AAExB,aAAWC,KAAWF,EAAa;AAEjC,IAAI7B,EAAG,2BAA2B+B,CAAO,IACvCD,EAAM,KAAKC,EAAQ,KAAK,IAAI,IAGrB/B,EAAG,aAAa+B,CAAO,KAC9BD,EAAM,KAAKC,EAAQ,IAAI;AAI3B,SAAOD;AACT;AAKA,SAAStB,EAAsBD,GAAiD;AAC9E,MAAIP,EAAG,aAAaO,EAAS,UAAU;AACrC,WAAOA,EAAS,WAAW;AAE7B,MAAIP,EAAG,2BAA2BO,EAAS,UAAU;AACnD,WAAOA,EAAS,WAAW,KAAK;AAGpC;AAKA,SAASI,EAAsBqB,GAAyC;AACtE,MAAIhC,EAAG,aAAagC,CAAI;AACtB,WAAOA,EAAK;AAGhB;"}

package/dist/test-utils/cli-runner.d.ts

@@ -0,0 +1,35 @@
+/**
+ * CLI runner utility for integration tests
+ *
+ * Provides functions to execute the CLI and capture output
+ */
+export interface CliResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+/**
+ * Run the CLI with the given arguments
+ *
+ * @param args - CLI arguments (e.g., ["generate", "schema.ts", "-d", "postgresql"])
+ * @param options - Optional configuration
+ * @returns Promise resolving to CLI output and exit code
+ */
+export declare function runCli(args: string[], options?: {
+    cwd?: string;
+    timeout?: number;
+}): Promise<CliResult>;
+/**
+ * Run the CLI generate command with common options
+ *
+ * @param schemaPath - Path to the schema file
+ * @param dialect - Database dialect
+ * @param options - Additional CLI options
+ * @returns Promise resolving to CLI output and exit code
+ */
+export declare function runGenerate(schemaPath: string, dialect: "postgresql" | "mysql" | "sqlite", options?: {
+    output?: string;
+    relational?: boolean;
+    cwd?: string;
+}): Promise<CliResult>;
+//# sourceMappingURL=cli-runner.d.ts.map

package/dist/test-utils/cli-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-runner.d.ts","sourceRoot":"","sources":["../../src/test-utils/cli-runner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/C,OAAO,CAAC,SAAS,CAAC,CA0CpB;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,YAAY,GAAG,OAAO,GAAG,QAAQ,EAC1C,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;CACT,GACL,OAAO,CAAC,SAAS,CAAC,CAYpB"}

package/dist/test-utils/dbml-validator.d.ts

@@ -0,0 +1,70 @@
+/**
+ * DBML validation utilities for integration tests
+ *
+ * Provides functions to validate DBML output structure
+ */
+/**
+ * Validate that the DBML output contains expected table definitions
+ *
+ * @param dbml - DBML output string
+ * @param tableNames - Expected table names
+ * @param quoteChar - Quote character used for identifiers (" for PG/SQLite, ` for MySQL)
+ * @returns true if all tables are present
+ */
+export declare function hasAllTables(dbml: string, tableNames: string[], quoteChar?: '"' | "`"): boolean;
+/**
+ * Validate that the DBML output contains expected columns in a table
+ *
+ * @param dbml - DBML output string
+ * @param tableName - Table name to check
+ * @param columnNames - Expected column names
+ * @param quoteChar - Quote character used for identifiers
+ * @returns true if all columns are present
+ */
+export declare function hasAllColumns(dbml: string, tableName: string, columnNames: string[], quoteChar?: '"' | "`"): boolean;
+/**
+ * Check if DBML contains a reference (foreign key relationship)
+ *
+ * @param dbml - DBML output string
+ * @param fromTable - Source table name
+ * @param fromColumn - Source column name
+ * @param toTable - Target table name
+ * @param toColumn - Target column name
+ * @param quoteChar - Quote character used for identifiers
+ * @returns true if the reference exists
+ */
+export declare function hasReference(dbml: string, fromTable: string, fromColumn: string, toTable: string, toColumn: string, quoteChar?: '"' | "`"): boolean;
+/**
+ * Check if DBML contains indexes section for a table
+ *
+ * @param dbml - DBML output string
+ * @param tableName - Table name to check
+ * @param quoteChar - Quote character used for identifiers
+ * @returns true if indexes section exists
+ */
+export declare function hasIndexes(dbml: string, tableName: string, quoteChar?: '"' | "`"): boolean;
+/**
+ * Check if DBML contains a Note clause for a table
+ *
+ * @param dbml - DBML output string
+ * @param tableName - Table name to check
+ * @param noteText - Expected note text (partial match)
+ * @param quoteChar - Quote character used for identifiers
+ * @returns true if the note exists
+ */
+export declare function hasTableNote(dbml: string, tableName: string, noteText: string, quoteChar?: '"' | "`"): boolean;
+/**
+ * Count the number of tables in DBML output
+ *
+ * @param dbml - DBML output string
+ * @returns Number of tables
+ */
+export declare function countTables(dbml: string): number;
+/**
+ * Count the number of Ref statements in DBML output
+ *
+ * @param dbml - DBML output string
+ * @returns Number of references
+ */
+export declare function countRefs(dbml: string): number;
+//# sourceMappingURL=dbml-validator.d.ts.map

package/dist/test-utils/dbml-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbml-validator.d.ts","sourceRoot":"","sources":["../../src/test-utils/dbml-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,GAAE,GAAG,GAAG,GAAS,GACzB,OAAO,CAET;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EAAE,EACrB,SAAS,GAAE,GAAG,GAAG,GAAS,GACzB,OAAO,CAqBT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,GAAG,GAAG,GAAS,GACzB,OAAO,CAOT;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAE,GAAG,GAAG,GAAS,GAAG,OAAO,CAqB/F;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,GAAG,GAAG,GAAS,GACzB,OAAO,CAqBT;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG9C"}

package/dist/test-utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Test utilities for integration testing
+ */
+export { runCli, runGenerate } from './cli-runner.js';
+export type { CliResult } from './cli-runner.js';
+export { hasAllTables, hasAllColumns, hasReference, hasIndexes, hasTableNote, countTables, countRefs, } from './dbml-validator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test-utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test-utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACtD,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EACL,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,WAAW,EACX,SAAS,GACV,MAAM,qBAAqB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,53 @@
+import { AnyColumn, Table } from 'drizzle-orm';
+import { SchemaComments } from './parser/comments';
+export type { AnyColumn, Table };
+/**
+ * Options for DBML generation
+ */
+export interface GenerateOptions<TSchema extends Record<string, unknown>> {
+    /** The Drizzle schema object containing tables and optionally relations */
+    schema: TSchema;
+    /** Output file path. If provided, DBML will be written to this file */
+    out?: string;
+    /** If true, uses relations() definitions instead of foreign keys for references */
+    relational?: boolean;
+    /**
+     * Path to the source schema file or directory for extracting JSDoc comments and relations.
+     * If a directory is provided, all .ts files will be processed recursively.
+     * Comments will be extracted and included as DBML Note clauses.
+     */
+    source?: string;
+    /**
+     * Pre-extracted comments to use for DBML Note clauses.
+     * Alternative to source - use this if you've already extracted comments.
+     */
+    comments?: SchemaComments;
+}
+/**
+ * Supported relation types in DBML
+ */
+export type RelationType = "one-to-one" | "one-to-many" | "many-to-one";
+/**
+ * Internal representation of a reference/relationship
+ */
+export interface GeneratedRef {
+    fromTable: string;
+    fromColumns: string[];
+    toTable: string;
+    toColumns: string[];
+    type: "<" | ">" | "-";
+    onDelete?: string;
+    onUpdate?: string;
+}
+/**
+ * Column constraint attributes for DBML output
+ */
+export interface ColumnAttributes {
+    primaryKey?: boolean;
+    notNull?: boolean;
+    unique?: boolean;
+    increment?: boolean;
+    default?: string;
+    note?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,YAAY,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;AAEjC;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACtE,2EAA2E;IAC3E,MAAM,EAAE,OAAO,CAAC;IAChB,uEAAuE;IACvE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,mFAAmF;IACnF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,aAAa,GAAG,aAAa,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "drizzle-docs-generator",
+  "version": "0.1.0",
+  "description": "A CLI tool that generates DBML files from Drizzle ORM schema definitions.",
+  "keywords": [
+    "cli",
+    "database",
+    "dbml",
+    "documentation",
+    "drizzle",
+    "drizzle-orm",
+    "schema",
+    "typescript"
+  ],
+  "homepage": "https://github.com/rikeda71/drizzle-docs-generator#readme",
+  "bugs": {
+    "url": "https://github.com/rikeda71/drizzle-docs-generator/issues"
+  },
+  "license": "MIT",
+  "author": "rikeda71",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rikeda71/drizzle-docs-generator.git"
+  },
+  "bin": {
+    "drizzle-docs": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^14.0.2",
+    "drizzle-orm": "1.0.0-beta.10-42c284e"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.7",
+    "oxfmt": "^0.23.0",
+    "oxlint": "^1.38.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.16"
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.44.0 || >=1.0.0-beta.0"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "lint": "oxlint",
+    "format": "oxfmt --write",
+    "format:check": "oxfmt --check",
+    "typecheck": "tsc --noEmit"
+  }
+}