prisma-flare 1.2.9 → 1.3.1

package/README.md

@@ -23,6 +23,7 @@ npm install prisma-flare
 |----------------|-------------------|---------|
 | 5.x - 7.x | `prisma-client-js` | ✅ |
 | 7.x+ | `prisma-client` | ✅ |
+| 7.x+ | Multi-file schema | ✅ |
 
 ## Quick Start
 
@@ -130,7 +131,19 @@ const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL });
 export const db = new FlareClient({ adapter });
 ```
 
-See [Configuration](docs/configuration.md#new-provider-prisma-client---prisma-7) for full setup.
+### Multi-File Schema (Prisma 7+)
+
+prisma-flare automatically supports multi-file schemas. Just run `npx prisma-flare generate`:
+
+```
+prisma/schema/
+├── _base.prisma    # generator & datasource (can be in any file)
+├── user.prisma
+├── post.prisma
+└── ...
+```
+
+See [Configuration](docs/configuration.md#schema-auto-detection) for details.
 
 ## Transactions
 

package/dist/cli/db-migrate.cjs

@@ -28,7 +28,7 @@ var import_child_process = require("child_process");
 
 // src/cli/generate-client.ts
 var fs3 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
+var path4 = __toESM(require("path"), 1);
 
 // src/cli/config.ts
 var fs = __toESM(require("fs"), 1);
@@ -66,8 +66,122 @@ function loadConfig(rootDir) {
 }
 
 // src/cli/schema-parser.ts
+var path3 = __toESM(require("path"), 1);
+
+// src/cli/schema-resolver.ts
 var fs2 = __toESM(require("fs"), 1);
 var path2 = __toESM(require("path"), 1);
+function readPrismaConfigSchema(rootDir) {
+  const configPaths = [
+    path2.join(rootDir, "prisma.config.ts"),
+    path2.join(rootDir, "prisma.config.js"),
+    path2.join(rootDir, "prisma.config.mjs"),
+    path2.join(rootDir, "prisma.config.cjs")
+  ];
+  for (const configPath of configPaths) {
+    if (!fs2.existsSync(configPath)) {
+      continue;
+    }
+    try {
+      const content = fs2.readFileSync(configPath, "utf-8");
+      const schemaMatch = content.match(/schema\s*:\s*["']([^"']+)["']/);
+      if (schemaMatch) {
+        return schemaMatch[1];
+      }
+      const schemaMatchUnquoted = content.match(/schema\s*:\s*([^\s,}]+)/);
+      if (schemaMatchUnquoted && !schemaMatchUnquoted[1].startsWith("//")) {
+        const value = schemaMatchUnquoted[1].trim();
+        return value.replace(/^["']|["']$/g, "");
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function mergeSchemaDirectory(dirPath) {
+  const files = getPrismaFiles(dirPath);
+  const contents = [];
+  for (const file of files) {
+    const filePath = path2.join(dirPath, file);
+    const content = fs2.readFileSync(filePath, "utf-8");
+    contents.push(content);
+  }
+  return contents.join("\n\n");
+}
+function getPrismaFiles(dirPath) {
+  if (!fs2.existsSync(dirPath) || !fs2.statSync(dirPath).isDirectory()) {
+    throw new Error(`Schema directory not found: ${dirPath}`);
+  }
+  const files = fs2.readdirSync(dirPath).filter((file) => file.endsWith(".prisma"));
+  if (files.length === 0) {
+    throw new Error(`No .prisma files found in directory: ${dirPath}`);
+  }
+  return files;
+}
+function findGeneratorFile(dirPath) {
+  const files = getPrismaFiles(dirPath);
+  for (const file of files) {
+    const filePath = path2.join(dirPath, file);
+    const content = fs2.readFileSync(filePath, "utf-8");
+    if (/generator\s+\w+\s*\{/.test(content)) {
+      return content;
+    }
+  }
+  return null;
+}
+function resolveSchemaPath(rootDir) {
+  let schemaPath = null;
+  const prismaConfigSchema = readPrismaConfigSchema(rootDir);
+  if (prismaConfigSchema) {
+    schemaPath = path2.isAbsolute(prismaConfigSchema) ? prismaConfigSchema : path2.join(rootDir, prismaConfigSchema);
+  }
+  if (!schemaPath) {
+    const schemaDir = path2.join(rootDir, "prisma", "schema");
+    if (fs2.existsSync(schemaDir) && fs2.statSync(schemaDir).isDirectory()) {
+      schemaPath = schemaDir;
+    }
+  }
+  if (!schemaPath) {
+    const singleFile = path2.join(rootDir, "prisma", "schema.prisma");
+    if (fs2.existsSync(singleFile)) {
+      schemaPath = singleFile;
+    }
+  }
+  if (!schemaPath) {
+    return null;
+  }
+  if (!fs2.existsSync(schemaPath)) {
+    return null;
+  }
+  const stat = fs2.statSync(schemaPath);
+  if (stat.isDirectory()) {
+    try {
+      const content = mergeSchemaDirectory(schemaPath);
+      const generatorContent = findGeneratorFile(schemaPath) || content;
+      return {
+        schemaPath,
+        isDirectory: true,
+        content,
+        generatorContent,
+        schemaDir: schemaPath
+      };
+    } catch {
+      return null;
+    }
+  } else if (stat.isFile()) {
+    const content = fs2.readFileSync(schemaPath, "utf-8");
+    return {
+      schemaPath,
+      isDirectory: false,
+      content,
+      generatorContent: content,
+      schemaDir: path2.dirname(schemaPath)
+    };
+  }
+  return null;
+}
+
+// src/cli/schema-parser.ts
 function parseGeneratorClient(schemaContent) {
   const generatorRegex = /generator\s+client\s*\{([^}]+)\}/s;
   const match = schemaContent.match(generatorRegex);
@@ -84,39 +198,36 @@ function parseGeneratorClient(schemaContent) {
   }
   return config;
 }
-function resolvePrismaClientPath(rootDir, output) {
+function resolvePrismaClientPath(rootDir, output, schemaDir) {
   if (!output) {
     return "@prisma/client";
   }
-  const schemaDir = path2.join(rootDir, "prisma");
-  const absolutePath = path2.resolve(schemaDir, output);
+  const resolvedSchemaDir = schemaDir || path3.join(rootDir, "prisma");
+  const absolutePath = path3.resolve(resolvedSchemaDir, output);
   return absolutePath;
 }
 function getPrismaClientPath(rootDir) {
-  const schemaPath = path2.join(rootDir, "prisma", "schema.prisma");
-  if (!fs2.existsSync(schemaPath)) {
+  const resolution = resolveSchemaPath(rootDir);
+  if (!resolution) {
     return "@prisma/client";
   }
-  const schemaContent = fs2.readFileSync(schemaPath, "utf-8");
-  const config = parseGeneratorClient(schemaContent);
-  return resolvePrismaClientPath(rootDir, config?.output);
+  const config = parseGeneratorClient(resolution.generatorContent);
+  return resolvePrismaClientPath(rootDir, config?.output, resolution.schemaDir);
 }
 function hasCustomPrismaOutput(rootDir) {
-  const schemaPath = path2.join(rootDir, "prisma", "schema.prisma");
-  if (!fs2.existsSync(schemaPath)) {
+  const resolution = resolveSchemaPath(rootDir);
+  if (!resolution) {
     return false;
   }
-  const schemaContent = fs2.readFileSync(schemaPath, "utf-8");
-  const config = parseGeneratorClient(schemaContent);
+  const config = parseGeneratorClient(resolution.generatorContent);
   return config?.output != null;
 }
 function getPrismaProvider(rootDir) {
-  const schemaPath = path2.join(rootDir, "prisma", "schema.prisma");
-  if (!fs2.existsSync(schemaPath)) {
+  const resolution = resolveSchemaPath(rootDir);
+  if (!resolution) {
     return "prisma-client-js";
   }
-  const schemaContent = fs2.readFileSync(schemaPath, "utf-8");
-  const config = parseGeneratorClient(schemaContent);
+  const config = parseGeneratorClient(resolution.generatorContent);
   return config?.provider || "prisma-client-js";
 }
 function parseModelRelations(schemaContent) {
@@ -185,12 +296,11 @@ ${entries.join(",\n")}
 };`;
 }
 function getRelationModelMap(rootDir) {
-  const schemaPath = path2.join(rootDir, "prisma", "schema.prisma");
-  if (!fs2.existsSync(schemaPath)) {
+  const resolution = resolveSchemaPath(rootDir);
+  if (!resolution) {
     return null;
   }
-  const schemaContent = fs2.readFileSync(schemaPath, "utf-8");
-  const models = parseModelRelations(schemaContent);
+  const models = parseModelRelations(resolution.content);
   return generateRelationModelMap(models);
 }
 
@@ -454,53 +564,53 @@ var FLARE_BUILDER_METHODS = {
   whereConditions: [
     {
       name: "where",
-      signature: "(condition: WhereInput<T>): FlareBuilder<T, Args & { where: WhereInput<T> }>"
+      signature: "(condition: WhereInput<T>): this"
     },
     {
       name: "andWhere",
-      signature: "(condition: WhereInput<T>): FlareBuilder<T, Args & { where: WhereInput<T> }>"
+      signature: "(condition: WhereInput<T>): this"
     },
     {
       name: "orWhere",
-      signature: "(condition: WhereInput<T>): FlareBuilder<T, Args & { where: WhereInput<T> }>"
+      signature: "(condition: WhereInput<T>): this"
     },
     {
       name: "whereGroup",
-      signature: "(callback: (builder: FlareBuilder<T, Record<string, never>>) => FlareBuilder<T, any>, mode?: 'AND' | 'OR'): FlareBuilder<T, Args & { where: WhereInput<T> }>"
+      signature: "(callback: (builder: FlareBuilder<T, Record<string, never>>) => FlareBuilder<T, any>, mode?: 'AND' | 'OR'): this"
     },
     {
       name: "orWhereGroup",
-      signature: "(callback: (builder: FlareBuilder<T, Record<string, never>>) => FlareBuilder<T, any>): FlareBuilder<T, Args & { where: WhereInput<T> }>"
+      signature: "(callback: (builder: FlareBuilder<T, Record<string, never>>) => FlareBuilder<T, any>): this"
     },
     {
       name: "withId",
-      signature: "(id: number | string): FlareBuilder<T, Args & { where: { id: number | string } }>"
+      signature: "(id: number | string): this"
     }
   ],
   orderingAndLimiting: [
     {
       name: "order",
-      signature: "(orderBy: OrderByInput<T>): FlareBuilder<T, Args & { orderBy: OrderByInput<T> }>"
+      signature: "(orderBy: OrderByInput<T>): this"
     },
     {
       name: "first",
-      signature: "(key?: keyof RecordType<T> | string): FlareBuilder<T, Args & { orderBy: any; take: number }>"
+      signature: "(key?: keyof RecordType<T> | string): this"
     },
     {
       name: "last",
-      signature: "(key?: keyof RecordType<T> | string): FlareBuilder<T, Args & { orderBy: any; take: number }>"
+      signature: "(key?: keyof RecordType<T> | string): this"
     },
     {
       name: "limit",
-      signature: "(count: number): FlareBuilder<T, Args & { take: number }>"
+      signature: "(count: number): this"
     },
     {
       name: "skip",
-      signature: "(count: number): FlareBuilder<T, Args & { skip: number }>"
+      signature: "(count: number): this"
     },
     {
       name: "distinct",
-      signature: "(fields: DistinctInput<T>): FlareBuilder<T, Args & { distinct: DistinctInput<T> }>"
+      signature: "(fields: DistinctInput<T>): this"
     }
   ],
   selection: [
@@ -624,7 +734,7 @@ var FLARE_BUILDER_METHODS = {
   utilities: [
     {
       name: "when",
-      signature: "(condition: boolean | (() => boolean), callback: (qb: FlareBuilder<T, Args>) => void): FlareBuilder<T, Args>"
+      signature: "(condition: boolean | (() => boolean), callback: (qb: this) => void): this"
     },
     {
       name: "chunk",
@@ -912,14 +1022,14 @@ function generateForNewProvider(rootDir, prismaClientPath) {
   if (!fs3.existsSync(prismaClientPath)) {
     fs3.mkdirSync(prismaClientPath, { recursive: true });
   }
-  const flareFilePath = path3.join(prismaClientPath, "flare.ts");
+  const flareFilePath = path4.join(prismaClientPath, "flare.ts");
   const content = generateNewProviderContent(rootDir);
   fs3.writeFileSync(flareFilePath, content);
   console.log(`\u2705 Generated prisma-flare client for new prisma-client provider`);
   console.log(`   Location: ${flareFilePath}`);
   console.log(
     `
-   Import: import { FlareClient } from '${path3.relative(rootDir, flareFilePath).replace(/\\/g, "/").replace(".ts", ".js")}';`
+   Import: import { FlareClient } from '${path4.relative(rootDir, flareFilePath).replace(/\\/g, "/").replace(".ts", ".js")}';`
   );
 }
 function generateCustomOutputTypes(rootDir, resolvedImport, useFlareResult = false) {
@@ -1061,8 +1171,8 @@ function generateClient() {
   if (isNewProvider && isCustomOutput) {
     generateForNewProvider(rootDir, prismaClientImport);
   }
-  const nodeModulesDir = path3.join(rootDir, "node_modules");
-  const prismaFlareDir = path3.join(nodeModulesDir, "prisma-flare-generated");
+  const nodeModulesDir = path4.join(rootDir, "node_modules");
+  const prismaFlareDir = path4.join(nodeModulesDir, "prisma-flare-generated");
   if (!fs3.existsSync(prismaFlareDir)) {
     fs3.mkdirSync(prismaFlareDir, { recursive: true });
   }
@@ -1072,7 +1182,7 @@ function generateClient() {
     resolvedImport = "@prisma/client";
     resolvedImportForJs = "@prisma/client";
   } else {
-    resolvedImport = path3.relative(prismaFlareDir, prismaClientImport);
+    resolvedImport = path4.relative(prismaFlareDir, prismaClientImport);
     if (!resolvedImport.startsWith(".")) {
       resolvedImport = "./" + resolvedImport;
     }
@@ -1123,8 +1233,8 @@ export const afterUpsert = _afterUpsert;
 export { hookRegistry };
 `;
   const dtsContent = isCustomOutput ? generateCustomOutputTypes(rootDir, resolvedImportForJs, isNewProvider) : generateDefaultTypes(resolvedImport);
-  fs3.writeFileSync(path3.join(prismaFlareDir, "index.js"), esmContent);
-  fs3.writeFileSync(path3.join(prismaFlareDir, "index.d.ts"), dtsContent);
+  fs3.writeFileSync(path4.join(prismaFlareDir, "index.js"), esmContent);
+  fs3.writeFileSync(path4.join(prismaFlareDir, "index.d.ts"), dtsContent);
   const packageJson = {
     name: "prisma-flare-generated",
     version: "0.0.0",
@@ -1140,7 +1250,7 @@ export { hookRegistry };
       }
     }
   };
-  fs3.writeFileSync(path3.join(prismaFlareDir, "package.json"), JSON.stringify(packageJson, null, 2));
+  fs3.writeFileSync(path4.join(prismaFlareDir, "package.json"), JSON.stringify(packageJson, null, 2));
   if (isCustomOutput) {
     console.log(`\u2705 Generated prisma-flare client with custom Prisma output: ${prismaClientImport}`);
   } else {
@@ -1279,7 +1389,7 @@ export declare const hookRegistry: typeof _hookRegistry;
 
 // src/cli/generate-queries.ts
 var fs4 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
+var path5 = __toESM(require("path"), 1);
 var import_pluralize = __toESM(require("pluralize"), 1);
 function toCamelCase(str) {
   return str.charAt(0).toLowerCase() + str.slice(1);
@@ -1313,41 +1423,44 @@ function parseRelations(schemaContent, models) {
 function generateQueries() {
   const rootDir = findProjectRoot(process.cwd());
   const config = loadConfig(rootDir);
-  const schemaPath = path4.join(rootDir, "prisma", "schema.prisma");
-  if (!fs4.existsSync(schemaPath)) {
-    console.error(`\u274C Schema not found at ${schemaPath}`);
+  const resolution = resolveSchemaPath(rootDir);
+  if (!resolution) {
+    console.error(`\u274C Schema not found. Looked for:`);
+    console.error(`   - prisma.config.ts (Prisma 7+)`);
+    console.error(`   - prisma/schema/ directory`);
+    console.error(`   - prisma/schema.prisma file`);
     return;
   }
-  const schemaContent = fs4.readFileSync(schemaPath, "utf-8");
+  const schemaContent = resolution.content;
   const modelRegex = /model\s+(\w+)\s+{/g;
   const models = [];
   let match;
   while ((match = modelRegex.exec(schemaContent)) !== null) {
     models.push(match[1]);
   }
-  const queriesDir = path4.join(rootDir, config.modelsPath);
+  const queriesDir = path5.join(rootDir, config.modelsPath);
   if (!fs4.existsSync(queriesDir)) {
     fs4.mkdirSync(queriesDir, { recursive: true });
   }
-  const absDbPath = path4.join(rootDir, config.dbPath);
-  let relativePathToDb = path4.relative(queriesDir, absDbPath);
+  const absDbPath = path5.join(rootDir, config.dbPath);
+  let relativePathToDb = path5.relative(queriesDir, absDbPath);
   if (!relativePathToDb.startsWith(".")) relativePathToDb = "./" + relativePathToDb;
   relativePathToDb = relativePathToDb.replace(/\\/g, "/");
   const _provider = getPrismaProvider(rootDir);
   void _provider;
   models.forEach((model) => {
     const queryFileName = `${model}.ts`;
-    const queryFilePath = path4.join(queriesDir, queryFileName);
+    const queryFilePath = path5.join(queriesDir, queryFileName);
     const modelCamel = toCamelCase(model);
     if (fs4.existsSync(queryFilePath)) {
       return;
     }
     console.log(`Generating ${queryFileName}...`);
     let queryBuilderImport = "import { FlareBuilder } from 'prisma-flare/client';";
-    const localQueryBuilderPath = path4.join(rootDir, "src/core/flareBuilder.ts");
+    const localQueryBuilderPath = path5.join(rootDir, "src/core/flareBuilder.ts");
     if (fs4.existsSync(localQueryBuilderPath)) {
-      const absSrcPath = path4.join(rootDir, "src");
-      let relativePathToSrc = path4.relative(queriesDir, absSrcPath);
+      const absSrcPath = path5.join(rootDir, "src");
+      let relativePathToSrc = path5.relative(queriesDir, absSrcPath);
       if (!relativePathToSrc.startsWith(".")) relativePathToSrc = "./" + relativePathToSrc;
       relativePathToSrc = relativePathToSrc.replace(/\\/g, "/");
       queryBuilderImport = `import { FlareBuilder } from '${relativePathToSrc}';`;
@@ -1364,12 +1477,12 @@ export default class ${model} extends FlareBuilder<'${modelCamel}'> {
     fs4.writeFileSync(queryFilePath, content);
   });
   let pfDistDir;
-  const pfPackageDir = path4.join(rootDir, "node_modules", "prisma-flare");
+  const pfPackageDir = path5.join(rootDir, "node_modules", "prisma-flare");
   let realPfPackageDir = pfPackageDir;
   if (fs4.existsSync(pfPackageDir)) {
     realPfPackageDir = fs4.realpathSync(pfPackageDir);
   }
-  pfDistDir = path4.join(realPfPackageDir, "dist");
+  pfDistDir = path5.join(realPfPackageDir, "dist");
   let dbPathWithExt = absDbPath;
   if (!absDbPath.endsWith(".ts") && !absDbPath.endsWith(".js")) {
     if (fs4.existsSync(absDbPath + ".ts")) {
@@ -1378,12 +1491,12 @@ export default class ${model} extends FlareBuilder<'${modelCamel}'> {
       dbPathWithExt = absDbPath + ".js";
     }
   }
-  let relativePathToDbForDist = path4.relative(pfDistDir, dbPathWithExt);
+  let relativePathToDbForDist = path5.relative(pfDistDir, dbPathWithExt);
   if (!relativePathToDbForDist.startsWith(".")) relativePathToDbForDist = "./" + relativePathToDbForDist;
   relativePathToDbForDist = relativePathToDbForDist.replace(/\\/g, "/");
   const relativePathToDbForDts = relativePathToDbForDist;
-  const absModelsPath = path4.join(queriesDir);
-  let relativePathToModels = path4.relative(pfDistDir, absModelsPath);
+  const absModelsPath = path5.join(queriesDir);
+  let relativePathToModels = path5.relative(pfDistDir, absModelsPath);
   if (!relativePathToModels.startsWith(".")) relativePathToModels = "./" + relativePathToModels;
   relativePathToModels = relativePathToModels.replace(/\\/g, "/");
   const relations = parseRelations(schemaContent, models);
@@ -1409,7 +1522,7 @@ export default class ${model} extends FlareBuilder<'${modelCamel}'> {
     }
   }
   const modelRegistrations = registrationLines.join("\n");
-  const generatedJsPath = path4.join(pfDistDir, "generated.js");
+  const generatedJsPath = path5.join(pfDistDir, "generated.js");
   const imports = models.map((model) => {
     return `import ${model} from '${relativePathToModels}/${model}.ts';`;
   }).join("\n");
@@ -1430,7 +1543,7 @@ ${getters}
 }
 `;
   fs4.writeFileSync(generatedJsPath, generatedContent);
-  const generatedCjsPath = path4.join(pfDistDir, "generated.cjs");
+  const generatedCjsPath = path5.join(pfDistDir, "generated.cjs");
   const importsCjs = models.map((model) => {
     return `const ${model} = require('${relativePathToModels}/${model}').default;`;
   }).join("\n");
@@ -1452,7 +1565,7 @@ ${getters}
 exports.DB = DB;
 `;
   fs4.writeFileSync(generatedCjsPath, generatedCjsContent);
-  const generatedDtsPath = path4.join(pfDistDir, "generated.d.ts");
+  const generatedDtsPath = path5.join(pfDistDir, "generated.d.ts");
   const importsDts = models.map((model) => {
     return `import ${model} from '${relativePathToModels}/${model}.ts';`;
   }).join("\n");
@@ -1503,11 +1616,11 @@ ${gettersTypes}
 
 // src/cli/generate-callbacks.ts
 var fs5 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
+var path6 = __toESM(require("path"), 1);
 function generateCallbacksIndex() {
   const rootDir = findProjectRoot(process.cwd());
   const config = loadConfig(rootDir);
-  const callbacksDir = path5.join(rootDir, config.callbacksPath);
+  const callbacksDir = path6.join(rootDir, config.callbacksPath);
   if (!fs5.existsSync(callbacksDir)) {
     console.log(`\u2139\uFE0F  Callbacks directory not found: ${callbacksDir}`);
     return;
@@ -1533,7 +1646,7 @@ function generateCallbacksIndex() {
 
 ${imports}
 `;
-  const indexPath = path5.join(callbacksDir, "index.ts");
+  const indexPath = path6.join(callbacksDir, "index.ts");
   fs5.writeFileSync(indexPath, content);
   console.log(`\u2705 Generated callbacks index: ${callbacksDir}/index.ts (${callbackFiles.length} callbacks)`);
 }