prisma-flare 1.0.0

package/dist/cli/db-migrate.cjs

@@ -0,0 +1,318 @@
+#!/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/db-migrate.ts
+var import_child_process = require("child_process");
+var dotenv = __toESM(require("dotenv"), 1);
+
+// 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 config3 = {
+    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);
+      config3 = { ...config3, ...userConfig };
+    } catch {
+      console.warn("\u26A0\uFE0F Could not read prisma-flare.config.json, using defaults.");
+    }
+  }
+  return {
+    ...config3
+  };
+}
+
+// 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 config3 = 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, config3.modelsPath);
+  if (!fs2.existsSync(queriesDir)) {
+    fs2.mkdirSync(queriesDir, { recursive: true });
+  }
+  const absDbPath = path2.join(rootDir, config3.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 = config3.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 = config3.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 = config3.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 = config3.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/db-migrate.ts
+var config2 = loadConfig();
+dotenv.config({ path: config2.envPath });
+function runMigrations() {
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    console.error("\u274C DATABASE_URL environment variable is not set");
+    process.exit(1);
+  }
+  try {
+    console.log("\u{1F504} Running Prisma migrations...");
+    const args = process.argv.slice(2).join(" ");
+    const command = `npx prisma migrate dev ${args} && npx prisma generate`;
+    console.log(`Running: ${command}`);
+    (0, import_child_process.execSync)(command, {
+      stdio: "inherit",
+      env: process.env
+    });
+    console.log("\u2713 Migrations completed successfully");
+    console.log("\u{1F504} Generating Query classes...");
+    generateQueries();
+    console.log("\u2713 Query classes generated successfully");
+    process.exit(0);
+  } catch (error) {
+    console.error("\u274C Error running migrations:", error);
+    process.exit(1);
+  }
+}
+runMigrations();

package/dist/cli/db-migrate.d.cts

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

package/dist/cli/db-migrate.d.ts

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

package/dist/cli/db-migrate.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+
+// src/cli/db-migrate.ts
+import { execSync } from "child_process";
+import * as dotenv from "dotenv";
+
+// 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 config3 = {
+    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);
+      config3 = { ...config3, ...userConfig };
+    } catch {
+      console.warn("\u26A0\uFE0F Could not read prisma-flare.config.json, using defaults.");
+    }
+  }
+  return {
+    ...config3
+  };
+}
+
+// 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 config3 = 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, config3.modelsPath);
+  if (!fs2.existsSync(queriesDir)) {
+    fs2.mkdirSync(queriesDir, { recursive: true });
+  }
+  const absDbPath = path2.join(rootDir, config3.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 = config3.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 = config3.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 = config3.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 = config3.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/db-migrate.ts
+var config2 = loadConfig();
+dotenv.config({ path: config2.envPath });
+function runMigrations() {
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    console.error("\u274C DATABASE_URL environment variable is not set");
+    process.exit(1);
+  }
+  try {
+    console.log("\u{1F504} Running Prisma migrations...");
+    const args = process.argv.slice(2).join(" ");
+    const command = `npx prisma migrate dev ${args} && npx prisma generate`;
+    console.log(`Running: ${command}`);
+    execSync(command, {
+      stdio: "inherit",
+      env: process.env
+    });
+    console.log("\u2713 Migrations completed successfully");
+    console.log("\u{1F504} Generating Query classes...");
+    generateQueries();
+    console.log("\u2713 Query classes generated successfully");
+    process.exit(0);
+  } catch (error) {
+    console.error("\u274C Error running migrations:", error);
+    process.exit(1);
+  }
+}
+runMigrations();