prisma-flare 1.0.0

package/dist/cli/index.cjs

@@ -0,0 +1,352 @@
+#!/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/generate-queries.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var import_pluralize = __toESM(require("pluralize"), 1);
+
+// src/cli/config.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+function findProjectRoot(currentDir) {
+  if (fs.existsSync(path.join(currentDir, "package.json"))) {
+    return currentDir;
+  }
+  const parentDir = path.dirname(currentDir);
+  if (parentDir === currentDir) {
+    throw new Error("Could not find package.json");
+  }
+  return findProjectRoot(parentDir);
+}
+function loadConfig(rootDir) {
+  const projectRoot = rootDir || findProjectRoot(process.cwd());
+  const configPath = path.join(projectRoot, "prisma-flare.config.json");
+  let config = {
+    modelsPath: "prisma/models",
+    dbPath: "prisma/db",
+    callbacksPath: "prisma/callbacks"
+  };
+  if (fs.existsSync(configPath)) {
+    try {
+      const configFile = fs.readFileSync(configPath, "utf-8");
+      const userConfig = JSON.parse(configFile);
+      config = { ...config, ...userConfig };
+    } catch {
+      console.warn("\u26A0\uFE0F Could not read prisma-flare.config.json, using defaults.");
+    }
+  }
+  return {
+    ...config
+  };
+}
+
+// src/cli/generate-queries.ts
+function toCamelCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function parseRelations(schemaContent, models) {
+  const relations = /* @__PURE__ */ new Map();
+  models.forEach((model) => relations.set(model, []));
+  const modelBlockRegex = /model\s+(\w+)\s+{([^}]+)}/g;
+  let modelMatch;
+  while ((modelMatch = modelBlockRegex.exec(schemaContent)) !== null) {
+    const modelName = modelMatch[1];
+    const modelBody = modelMatch[2];
+    const lines = modelBody.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@")) continue;
+      const fieldMatch = trimmed.match(/^(\w+)\s+(\w+)(\[\])?\s*/);
+      if (fieldMatch) {
+        const fieldName = fieldMatch[1];
+        const fieldType = fieldMatch[2];
+        const isArray = !!fieldMatch[3];
+        if (models.includes(fieldType)) {
+          const modelRelations = relations.get(modelName) || [];
+          modelRelations.push({ fieldName, targetModel: fieldType });
+          relations.set(modelName, modelRelations);
+        }
+      }
+    }
+  }
+  return relations;
+}
+function generateQueries() {
+  const rootDir = findProjectRoot(process.cwd());
+  const config = loadConfig(rootDir);
+  const schemaPath = path2.join(rootDir, "prisma", "schema.prisma");
+  if (!fs2.existsSync(schemaPath)) {
+    console.error(`\u274C Schema not found at ${schemaPath}`);
+    return;
+  }
+  const schemaContent = fs2.readFileSync(schemaPath, "utf-8");
+  const modelRegex = /model\s+(\w+)\s+{/g;
+  const models = [];
+  let match;
+  while ((match = modelRegex.exec(schemaContent)) !== null) {
+    models.push(match[1]);
+  }
+  const queriesDir = path2.join(rootDir, config.modelsPath);
+  if (!fs2.existsSync(queriesDir)) {
+    fs2.mkdirSync(queriesDir, { recursive: true });
+  }
+  const absDbPath = path2.join(rootDir, config.dbPath);
+  let relativePathToDb = path2.relative(queriesDir, absDbPath);
+  if (!relativePathToDb.startsWith(".")) relativePathToDb = "./" + relativePathToDb;
+  relativePathToDb = relativePathToDb.replace(/\\/g, "/");
+  models.forEach((model) => {
+    const queryFileName = `${model}.ts`;
+    const queryFilePath = path2.join(queriesDir, queryFileName);
+    const modelCamel = toCamelCase(model);
+    if (fs2.existsSync(queryFilePath)) {
+      return;
+    }
+    console.log(`Generating ${queryFileName}...`);
+    let queryBuilderImport = "import { FlareBuilder } from 'prisma-flare';";
+    const localQueryBuilderPath = path2.join(rootDir, "src/core/flareBuilder.ts");
+    if (fs2.existsSync(localQueryBuilderPath)) {
+      const absSrcPath = path2.join(rootDir, "src");
+      let relativePathToSrc = path2.relative(queriesDir, absSrcPath);
+      if (!relativePathToSrc.startsWith(".")) relativePathToSrc = "./" + relativePathToSrc;
+      relativePathToSrc = relativePathToSrc.replace(/\\/g, "/");
+      queryBuilderImport = `import { FlareBuilder } from '${relativePathToSrc}';`;
+    }
+    const content = `import { db } from '${relativePathToDb}';
+${queryBuilderImport}
+
+export default class ${model} extends FlareBuilder<'${modelCamel}'> {
+  constructor() {
+    super(db.${modelCamel});
+  }
+}
+`;
+    fs2.writeFileSync(queryFilePath, content);
+  });
+  let pfDistDir;
+  const pfPackageDir = path2.join(rootDir, "node_modules", "prisma-flare");
+  let realPfPackageDir = pfPackageDir;
+  if (fs2.existsSync(pfPackageDir)) {
+    realPfPackageDir = fs2.realpathSync(pfPackageDir);
+  }
+  pfDistDir = path2.join(realPfPackageDir, "dist");
+  let dbPathWithExt = absDbPath;
+  if (!absDbPath.endsWith(".ts") && !absDbPath.endsWith(".js")) {
+    if (fs2.existsSync(absDbPath + ".ts")) {
+      dbPathWithExt = absDbPath + ".ts";
+    } else if (fs2.existsSync(absDbPath + ".js")) {
+      dbPathWithExt = absDbPath + ".js";
+    }
+  }
+  let relativePathToDbForDist = path2.relative(pfDistDir, dbPathWithExt);
+  if (!relativePathToDbForDist.startsWith(".")) relativePathToDbForDist = "./" + relativePathToDbForDist;
+  relativePathToDbForDist = relativePathToDbForDist.replace(/\\/g, "/");
+  const relativePathToDbForDts = relativePathToDbForDist;
+  const absModelsPath = path2.join(queriesDir);
+  let relativePathToModels = path2.relative(pfDistDir, absModelsPath);
+  if (!relativePathToModels.startsWith(".")) relativePathToModels = "./" + relativePathToModels;
+  relativePathToModels = relativePathToModels.replace(/\\/g, "/");
+  const relations = parseRelations(schemaContent, models);
+  const getters = models.map((model) => {
+    const modelCamel = toCamelCase(model);
+    const customPlural = config.plurals?.[model];
+    const modelPlural = customPlural || (0, import_pluralize.default)(modelCamel);
+    return `  static get ${modelPlural}() {
+    return new ${model}();
+  }`;
+  }).join("\n\n");
+  const registrationLines = [];
+  models.forEach((model) => {
+    const modelCamel = toCamelCase(model);
+    const customPlural = config.plurals?.[model];
+    const modelPlural = customPlural || (0, import_pluralize.default)(modelCamel);
+    registrationLines.push(`modelRegistry.register('${modelCamel}', ${model});`);
+    registrationLines.push(`modelRegistry.register('${modelPlural}', ${model});`);
+  });
+  relations.forEach((rels, modelName) => {
+    rels.forEach((rel) => {
+      registrationLines.push(`modelRegistry.register('${rel.fieldName}', ${rel.targetModel});`);
+    });
+  });
+  const modelRegistrations = registrationLines.join("\n");
+  const generatedJsPath = path2.join(pfDistDir, "generated.js");
+  const imports = models.map((model) => {
+    return `import ${model} from '${relativePathToModels}/${model}.ts';`;
+  }).join("\n");
+  const generatedContent = `
+import { db } from '${relativePathToDbForDist}';
+import { modelRegistry } from './index.js';
+${imports}
+
+// Register all models so include() can use custom model classes
+${modelRegistrations}
+
+export class DB {
+  static get instance() {
+    return db;
+  }
+
+${getters}
+}
+`;
+  fs2.writeFileSync(generatedJsPath, generatedContent);
+  const generatedCjsPath = path2.join(pfDistDir, "generated.cjs");
+  const importsCjs = models.map((model) => {
+    return `const ${model} = require('${relativePathToModels}/${model}').default;`;
+  }).join("\n");
+  const generatedCjsContent = `
+const { db } = require('${relativePathToDbForDist}');
+const { modelRegistry } = require('./index.cjs');
+${importsCjs}
+
+// Register all models so include() can use custom model classes
+${modelRegistrations}
+
+class DB {
+  static get instance() {
+    return db;
+  }
+
+${getters}
+}
+exports.DB = DB;
+`;
+  fs2.writeFileSync(generatedCjsPath, generatedCjsContent);
+  const generatedDtsPath = path2.join(pfDistDir, "generated.d.ts");
+  const importsDts = models.map((model) => {
+    return `import ${model} from '${relativePathToModels}/${model}.ts';`;
+  }).join("\n");
+  const gettersTypes = models.map((model) => {
+    const modelCamel = toCamelCase(model);
+    const customPlural = config.plurals?.[model];
+    const modelPlural = customPlural || (0, import_pluralize.default)(modelCamel);
+    return `  static get ${modelPlural}(): ${model};`;
+  }).join("\n");
+  const relationMapEntries = [];
+  models.forEach((model) => {
+    const modelCamel = toCamelCase(model);
+    const customPlural = config.plurals?.[model];
+    const modelPlural = customPlural || (0, import_pluralize.default)(modelCamel);
+    relationMapEntries.push(`    ${modelCamel}: ${model};`);
+    relationMapEntries.push(`    ${modelPlural}: ${model};`);
+  });
+  relations.forEach((rels, modelName) => {
+    rels.forEach((rel) => {
+      const entry = `    ${rel.fieldName}: ${rel.targetModel};`;
+      if (!relationMapEntries.includes(entry)) {
+        relationMapEntries.push(entry);
+      }
+    });
+  });
+  const generatedDtsContent = `
+import { db } from '${relativePathToDbForDts}';
+${importsDts}
+
+/**
+ * Module augmentation to provide type-safe includes.
+ * This maps relation field names to their custom model classes.
+ */
+declare module 'prisma-flare' {
+  interface RelationModelMap {
+${relationMapEntries.join("\n")}
+  }
+}
+
+export declare class DB {
+  static get instance(): typeof db;
+
+${gettersTypes}
+}
+`;
+  fs2.writeFileSync(generatedDtsPath, generatedDtsContent);
+}
+
+// src/cli/index.ts
+var import_child_process = require("child_process");
+var path3 = __toESM(require("path"), 1);
+var fs3 = __toESM(require("fs"), 1);
+var import_url = require("url");
+var import_meta = {};
+var getDirname = () => {
+  try {
+    return path3.dirname((0, import_url.fileURLToPath)(import_meta.url));
+  } catch {
+    return __dirname;
+  }
+};
+var __dirname_ = getDirname();
+var args = process.argv.slice(2);
+var command = args[0];
+if (!command) {
+  console.log("Usage: prisma-flare <command>");
+  console.log("Commands:");
+  console.log("  generate    Generate query classes based on schema.prisma");
+  console.log("  create      Create the database");
+  console.log("  drop        Drop the database");
+  console.log("  migrate     Migrate the database");
+  console.log("  reset       Reset the database");
+  console.log("  seed        Seed the database");
+  process.exit(1);
+}
+switch (command) {
+  case "generate":
+    generateQueries();
+    break;
+  case "create":
+  case "drop":
+  case "migrate":
+  case "reset":
+  case "seed":
+    runScript(command);
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    process.exit(1);
+}
+function runScript(scriptName) {
+  const scriptMap = {
+    "create": "db-create.ts",
+    "drop": "db-drop.ts",
+    "migrate": "db-migrate.ts",
+    "reset": "db-reset.ts",
+    "seed": "db-seed.ts"
+  };
+  const file = scriptMap[scriptName];
+  if (!file) {
+    console.error(`No script found for ${scriptName}`);
+    return;
+  }
+  let scriptPath = path3.join(__dirname_, file.replace(".ts", ".js"));
+  if (!fs3.existsSync(scriptPath)) {
+    const cliScriptPath = path3.join(__dirname_, "cli", file.replace(".ts", ".js"));
+    if (fs3.existsSync(cliScriptPath)) {
+      scriptPath = cliScriptPath;
+    }
+  }
+  const child = (0, import_child_process.spawn)("node", [scriptPath], { stdio: "inherit" });
+  child.on("close", (code) => {
+    process.exit(code || 0);
+  });
+}

package/dist/cli/index.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+
+// src/cli/generate-queries.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import pluralize from "pluralize";
+
+// src/cli/config.ts
+import * as fs from "fs";
+import * as path from "path";
+function findProjectRoot(currentDir) {
+  if (fs.existsSync(path.join(currentDir, "package.json"))) {
+    return currentDir;
+  }
+  const parentDir = path.dirname(currentDir);
+  if (parentDir === currentDir) {
+    throw new Error("Could not find package.json");
+  }
+  return findProjectRoot(parentDir);
+}
+function loadConfig(rootDir) {
+  const projectRoot = rootDir || findProjectRoot(process.cwd());
+  const configPath = path.join(projectRoot, "prisma-flare.config.json");
+  let config = {
+    modelsPath: "prisma/models",
+    dbPath: "prisma/db",
+    callbacksPath: "prisma/callbacks"
+  };
+  if (fs.existsSync(configPath)) {
+    try {
+      const configFile = fs.readFileSync(configPath, "utf-8");
+      const userConfig = JSON.parse(configFile);
+      config = { ...config, ...userConfig };
+    } catch {
+      console.warn("\u26A0\uFE0F Could not read prisma-flare.config.json, using defaults.");
+    }
+  }
+  return {
+    ...config
+  };
+}
+
+// src/cli/generate-queries.ts
+function toCamelCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function parseRelations(schemaContent, models) {
+  const relations = /* @__PURE__ */ new Map();
+  models.forEach((model) => relations.set(model, []));
+  const modelBlockRegex = /model\s+(\w+)\s+{([^}]+)}/g;
+  let modelMatch;
+  while ((modelMatch = modelBlockRegex.exec(schemaContent)) !== null) {
+    const modelName = modelMatch[1];
+    const modelBody = modelMatch[2];
+    const lines = modelBody.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@")) continue;
+      const fieldMatch = trimmed.match(/^(\w+)\s+(\w+)(\[\])?\s*/);
+      if (fieldMatch) {
+        const fieldName = fieldMatch[1];
+        const fieldType = fieldMatch[2];
+        const isArray = !!fieldMatch[3];
+        if (models.includes(fieldType)) {
+          const modelRelations = relations.get(modelName) || [];
+          modelRelations.push({ fieldName, targetModel: fieldType });
+          relations.set(modelName, modelRelations);
+        }
+      }
+    }
+  }
+  return relations;
+}
+function generateQueries() {
+  const rootDir = findProjectRoot(process.cwd());
+  const config = loadConfig(rootDir);
+  const schemaPath = path2.join(rootDir, "prisma", "schema.prisma");
+  if (!fs2.existsSync(schemaPath)) {
+    console.error(`\u274C Schema not found at ${schemaPath}`);
+    return;
+  }
+  const schemaContent = fs2.readFileSync(schemaPath, "utf-8");
+  const modelRegex = /model\s+(\w+)\s+{/g;
+  const models = [];
+  let match;
+  while ((match = modelRegex.exec(schemaContent)) !== null) {
+    models.push(match[1]);
+  }
+  const queriesDir = path2.join(rootDir, config.modelsPath);
+  if (!fs2.existsSync(queriesDir)) {
+    fs2.mkdirSync(queriesDir, { recursive: true });
+  }
+  const absDbPath = path2.join(rootDir, config.dbPath);
+  let relativePathToDb = path2.relative(queriesDir, absDbPath);
+  if (!relativePathToDb.startsWith(".")) relativePathToDb = "./" + relativePathToDb;
+  relativePathToDb = relativePathToDb.replace(/\\/g, "/");
+  models.forEach((model) => {
+    const queryFileName = `${model}.ts`;
+    const queryFilePath = path2.join(queriesDir, queryFileName);
+    const modelCamel = toCamelCase(model);
+    if (fs2.existsSync(queryFilePath)) {
+      return;
+    }
+    console.log(`Generating ${queryFileName}...`);
+    let queryBuilderImport = "import { FlareBuilder } from 'prisma-flare';";
+    const localQueryBuilderPath = path2.join(rootDir, "src/core/flareBuilder.ts");
+    if (fs2.existsSync(localQueryBuilderPath)) {
+      const absSrcPath = path2.join(rootDir, "src");
+      let relativePathToSrc = path2.relative(queriesDir, absSrcPath);
+      if (!relativePathToSrc.startsWith(".")) relativePathToSrc = "./" + relativePathToSrc;
+      relativePathToSrc = relativePathToSrc.replace(/\\/g, "/");
+      queryBuilderImport = `import { FlareBuilder } from '${relativePathToSrc}';`;
+    }
+    const content = `import { db } from '${relativePathToDb}';
+${queryBuilderImport}
+
+export default class ${model} extends FlareBuilder<'${modelCamel}'> {
+  constructor() {
+    super(db.${modelCamel});
+  }
+}
+`;
+    fs2.writeFileSync(queryFilePath, content);
+  });
+  let pfDistDir;
+  const pfPackageDir = path2.join(rootDir, "node_modules", "prisma-flare");
+  let realPfPackageDir = pfPackageDir;
+  if (fs2.existsSync(pfPackageDir)) {
+    realPfPackageDir = fs2.realpathSync(pfPackageDir);
+  }
+  pfDistDir = path2.join(realPfPackageDir, "dist");
+  let dbPathWithExt = absDbPath;
+  if (!absDbPath.endsWith(".ts") && !absDbPath.endsWith(".js")) {
+    if (fs2.existsSync(absDbPath + ".ts")) {
+      dbPathWithExt = absDbPath + ".ts";
+    } else if (fs2.existsSync(absDbPath + ".js")) {
+      dbPathWithExt = absDbPath + ".js";
+    }
+  }
+  let relativePathToDbForDist = path2.relative(pfDistDir, dbPathWithExt);
+  if (!relativePathToDbForDist.startsWith(".")) relativePathToDbForDist = "./" + relativePathToDbForDist;
+  relativePathToDbForDist = relativePathToDbForDist.replace(/\\/g, "/");
+  const relativePathToDbForDts = relativePathToDbForDist;
+  const absModelsPath = path2.join(queriesDir);
+  let relativePathToModels = path2.relative(pfDistDir, absModelsPath);
+  if (!relativePathToModels.startsWith(".")) relativePathToModels = "./" + relativePathToModels;
+  relativePathToModels = relativePathToModels.replace(/\\/g, "/");
+  const relations = parseRelations(schemaContent, models);
+  const getters = models.map((model) => {
+    const modelCamel = toCamelCase(model);
+    const customPlural = config.plurals?.[model];
+    const modelPlural = customPlural || pluralize(modelCamel);
+    return `  static get ${modelPlural}() {
+    return new ${model}();
+  }`;
+  }).join("\n\n");
+  const registrationLines = [];
+  models.forEach((model) => {
+    const modelCamel = toCamelCase(model);
+    const customPlural = config.plurals?.[model];
+    const modelPlural = customPlural || pluralize(modelCamel);
+    registrationLines.push(`modelRegistry.register('${modelCamel}', ${model});`);
+    registrationLines.push(`modelRegistry.register('${modelPlural}', ${model});`);
+  });
+  relations.forEach((rels, modelName) => {
+    rels.forEach((rel) => {
+      registrationLines.push(`modelRegistry.register('${rel.fieldName}', ${rel.targetModel});`);
+    });
+  });
+  const modelRegistrations = registrationLines.join("\n");
+  const generatedJsPath = path2.join(pfDistDir, "generated.js");
+  const imports = models.map((model) => {
+    return `import ${model} from '${relativePathToModels}/${model}.ts';`;
+  }).join("\n");
+  const generatedContent = `
+import { db } from '${relativePathToDbForDist}';
+import { modelRegistry } from './index.js';
+${imports}
+
+// Register all models so include() can use custom model classes
+${modelRegistrations}
+
+export class DB {
+  static get instance() {
+    return db;
+  }
+
+${getters}
+}
+`;
+  fs2.writeFileSync(generatedJsPath, generatedContent);
+  const generatedCjsPath = path2.join(pfDistDir, "generated.cjs");
+  const importsCjs = models.map((model) => {
+    return `const ${model} = require('${relativePathToModels}/${model}').default;`;
+  }).join("\n");
+  const generatedCjsContent = `
+const { db } = require('${relativePathToDbForDist}');
+const { modelRegistry } = require('./index.cjs');
+${importsCjs}
+
+// Register all models so include() can use custom model classes
+${modelRegistrations}
+
+class DB {
+  static get instance() {
+    return db;
+  }
+
+${getters}
+}
+exports.DB = DB;
+`;
+  fs2.writeFileSync(generatedCjsPath, generatedCjsContent);
+  const generatedDtsPath = path2.join(pfDistDir, "generated.d.ts");
+  const importsDts = models.map((model) => {
+    return `import ${model} from '${relativePathToModels}/${model}.ts';`;
+  }).join("\n");
+  const gettersTypes = models.map((model) => {
+    const modelCamel = toCamelCase(model);
+    const customPlural = config.plurals?.[model];
+    const modelPlural = customPlural || pluralize(modelCamel);
+    return `  static get ${modelPlural}(): ${model};`;
+  }).join("\n");
+  const relationMapEntries = [];
+  models.forEach((model) => {
+    const modelCamel = toCamelCase(model);
+    const customPlural = config.plurals?.[model];
+    const modelPlural = customPlural || pluralize(modelCamel);
+    relationMapEntries.push(`    ${modelCamel}: ${model};`);
+    relationMapEntries.push(`    ${modelPlural}: ${model};`);
+  });
+  relations.forEach((rels, modelName) => {
+    rels.forEach((rel) => {
+      const entry = `    ${rel.fieldName}: ${rel.targetModel};`;
+      if (!relationMapEntries.includes(entry)) {
+        relationMapEntries.push(entry);
+      }
+    });
+  });
+  const generatedDtsContent = `
+import { db } from '${relativePathToDbForDts}';
+${importsDts}
+
+/**
+ * Module augmentation to provide type-safe includes.
+ * This maps relation field names to their custom model classes.
+ */
+declare module 'prisma-flare' {
+  interface RelationModelMap {
+${relationMapEntries.join("\n")}
+  }
+}
+
+export declare class DB {
+  static get instance(): typeof db;
+
+${gettersTypes}
+}
+`;
+  fs2.writeFileSync(generatedDtsPath, generatedDtsContent);
+}
+
+// src/cli/index.ts
+import { spawn } from "child_process";
+import * as path3 from "path";
+import * as fs3 from "fs";
+import { fileURLToPath } from "url";
+var getDirname = () => {
+  try {
+    return path3.dirname(fileURLToPath(import.meta.url));
+  } catch {
+    return __dirname;
+  }
+};
+var __dirname_ = getDirname();
+var args = process.argv.slice(2);
+var command = args[0];
+if (!command) {
+  console.log("Usage: prisma-flare <command>");
+  console.log("Commands:");
+  console.log("  generate    Generate query classes based on schema.prisma");
+  console.log("  create      Create the database");
+  console.log("  drop        Drop the database");
+  console.log("  migrate     Migrate the database");
+  console.log("  reset       Reset the database");
+  console.log("  seed        Seed the database");
+  process.exit(1);
+}
+switch (command) {
+  case "generate":
+    generateQueries();
+    break;
+  case "create":
+  case "drop":
+  case "migrate":
+  case "reset":
+  case "seed":
+    runScript(command);
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    process.exit(1);
+}
+function runScript(scriptName) {
+  const scriptMap = {
+    "create": "db-create.ts",
+    "drop": "db-drop.ts",
+    "migrate": "db-migrate.ts",
+    "reset": "db-reset.ts",
+    "seed": "db-seed.ts"
+  };
+  const file = scriptMap[scriptName];
+  if (!file) {
+    console.error(`No script found for ${scriptName}`);
+    return;
+  }
+  let scriptPath = path3.join(__dirname_, file.replace(".ts", ".js"));
+  if (!fs3.existsSync(scriptPath)) {
+    const cliScriptPath = path3.join(__dirname_, "cli", file.replace(".ts", ".js"));
+    if (fs3.existsSync(cliScriptPath)) {
+      scriptPath = cliScriptPath;
+    }
+  }
+  const child = spawn("node", [scriptPath], { stdio: "inherit" });
+  child.on("close", (code) => {
+    process.exit(code || 0);
+  });
+}