prisma-sql 1.9.0 → 1.10.0

package/dist/generator.cjs

@@ -31,7 +31,7 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     var fulfilled = (value) => {
       try {
         step(generator.next(value));
@@ -46,7 +46,7 @@ var __async = (__this, __arguments, generator) => {
         reject(e);
       }
     };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    var step = (x) => x.done ? resolve3(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
@@ -56,7 +56,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.9.0",
+      version: "1.10.0",
       description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
       main: "dist/index.cjs",
       module: "dist/index.js",
@@ -1340,7 +1340,7 @@ var NO_JOINS = Object.freeze([]);
 function isListRelation(fieldType) {
   return typeof fieldType === "string" && fieldType.endsWith("[]");
 }
-function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join2, wantNull) {
+function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join3, wantNull) {
   const isLocal = field.isForeignKeyLocal === true;
   const fkFields = normalizeKeyList(field.foreignKey);
   if (isLocal) {
@@ -1357,16 +1357,16 @@ function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join2, want
     if (parts.length === 1) return parts[0];
     return wantNull ? `(${parts.join(" OR ")})` : `(${parts.join(" AND ")})`;
   }
-  const existsSql = `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias} ${SQL_TEMPLATES.WHERE} ${join2})`;
+  const existsSql = `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias} ${SQL_TEMPLATES.WHERE} ${join3})`;
   return wantNull ? `${SQL_TEMPLATES.NOT} ${existsSql}` : existsSql;
 }
-function buildToOneExistsMatch(relTable, relAlias, join2, sub) {
+function buildToOneExistsMatch(relTable, relAlias, join3, sub) {
   const joins = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
-  return `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join2} ${SQL_TEMPLATES.AND} ${sub.clause})`;
+  return `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join3} ${SQL_TEMPLATES.AND} ${sub.clause})`;
 }
-function buildToOneNotExistsMatch(relTable, relAlias, join2, sub) {
+function buildToOneNotExistsMatch(relTable, relAlias, join3, sub) {
   const joins = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
-  return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join2} ${SQL_TEMPLATES.AND} ${sub.clause})`;
+  return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join3} ${SQL_TEMPLATES.AND} ${sub.clause})`;
 }
 function buildListRelationFilters(args) {
   const {
@@ -1377,7 +1377,7 @@ function buildListRelationFilters(args) {
     relModel,
     relTable,
     relAlias,
-    join: join2
+    join: join3
   } = args;
   const noneValue = value[RelationFilters.NONE];
   if (noneValue !== void 0 && noneValue !== null) {
@@ -1395,7 +1395,7 @@ function buildListRelationFilters(args) {
         (f) => !f.isRelation && f.isRequired && f.name !== "id"
       ) || relModel.fields.find((f) => !f.isRelation && f.name === "id");
       if (checkField) {
-        const leftJoinSql = `LEFT JOIN ${relTable} ${relAlias} ON ${join2}`;
+        const leftJoinSql = `LEFT JOIN ${relTable} ${relAlias} ON ${join3}`;
         const whereClause = `${relAlias}.${quote(checkField.name)} IS NULL`;
         return Object.freeze({
           clause: whereClause,
@@ -1407,17 +1407,17 @@ function buildListRelationFilters(args) {
   const filters = [
     {
       key: RelationFilters.SOME,
-      wrap: (c, j) => `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join2} ${SQL_TEMPLATES.AND} ${c})`
+      wrap: (c, j) => `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join3} ${SQL_TEMPLATES.AND} ${c})`
     },
     {
       key: RelationFilters.EVERY,
-      wrap: (c, j) => `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join2} ${SQL_TEMPLATES.AND} ${SQL_TEMPLATES.NOT} (${c}))`
+      wrap: (c, j) => `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join3} ${SQL_TEMPLATES.AND} ${SQL_TEMPLATES.NOT} (${c}))`
     },
     {
       key: RelationFilters.NONE,
       wrap: (c, j) => {
         const condition = c === DEFAULT_WHERE_CLAUSE ? "" : ` ${SQL_TEMPLATES.AND} ${c}`;
-        return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join2}${condition})`;
+        return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join3}${condition})`;
       }
     }
   ];
@@ -1456,7 +1456,7 @@ function buildToOneRelationFilters(args) {
     relModel,
     relTable,
     relAlias,
-    join: join2
+    join: join3
   } = args;
   const hasSomeEveryNone = isNotNullish(value[RelationFilters.SOME]) || isNotNullish(value[RelationFilters.EVERY]) || isNotNullish(value[RelationFilters.NONE]);
   if (hasSomeEveryNone) {
@@ -1492,7 +1492,7 @@ function buildToOneRelationFilters(args) {
       ctx.alias,
       relTable,
       relAlias,
-      join2,
+      join3,
       wantNull
     );
     return Object.freeze({
@@ -1518,7 +1518,7 @@ function buildToOneRelationFilters(args) {
     isSubquery: true,
     depth: ctx.depth + 1
   }));
-  const clause = filterKey === "is" ? buildToOneExistsMatch(relTable, relAlias, join2, sub) : buildToOneNotExistsMatch(relTable, relAlias, join2, sub);
+  const clause = filterKey === "is" ? buildToOneExistsMatch(relTable, relAlias, join3, sub) : buildToOneNotExistsMatch(relTable, relAlias, join3, sub);
   return Object.freeze({
     clause,
     joins: NO_JOINS
@@ -1560,7 +1560,7 @@ function buildRelation(fieldName, value, ctx, whereBuilder) {
     ctx.dialect
   );
   const relAlias = ctx.aliasGen.next(fieldName);
-  const join2 = joinCondition(field, ctx.alias, relAlias);
+  const join3 = joinCondition(field, ctx.alias, relAlias);
   const args = {
     fieldName,
     value,
@@ -1570,7 +1570,7 @@ function buildRelation(fieldName, value, ctx, whereBuilder) {
     relModel,
     relTable,
     relAlias,
-    join: join2
+    join: join3
   };
   if (isListRelation(field.type)) return buildListRelationFilters(args);
   return buildToOneRelationFilters(args);
@@ -4412,23 +4412,34 @@ function generateClient(options) {
         queries.set(modelName, modelQueries);
       }
     }
-    yield promises.mkdir(outputDir, { recursive: true });
+    const absoluteOutputDir = path.resolve(process.cwd(), outputDir);
+    yield promises.mkdir(absoluteOutputDir, { recursive: true });
     const code = generateCode(models, queries, config.dialect);
-    yield promises.writeFile(path.join(outputDir, "index.ts"), code);
+    const outputPath = path.join(absoluteOutputDir, "index.ts");
+    yield promises.writeFile(outputPath, code);
     const totalQueries = Array.from(queries.values()).reduce(
       (sum, m) => sum + m.size,
       0
     );
     console.log(`\u2713 Generated ${queries.size} models, ${totalQueries} queries`);
+    console.log(`\u2713 Output: ${outputPath}`);
   });
 }
 function generateCode(models, queries, dialect) {
+  const cleanModels = models.map((model) => __spreadProps(__spreadValues({}, model), {
+    fields: model.fields.filter((f) => f !== void 0 && f !== null)
+  }));
   return `// Generated by @prisma-sql/generator - DO NOT EDIT
 import { buildSQL, transformQueryResults, type PrismaMethod } from 'prisma-sql'
 
-const MODELS = ${JSON.stringify(models, null, 2)}
+const MODELS = ${JSON.stringify(cleanModels, null, 2)}
 
-const QUERIES = ${formatQueries(queries)}
+const QUERIES: Record<string, Record<string, {
+  sql: string
+  params: unknown[]
+  dynamicKeys: string[]
+  paramMappings: any[]
+}>> = ${formatQueries(queries)}
 
 const DIALECT = ${JSON.stringify(dialect)}
 
@@ -4504,7 +4515,6 @@ export function createExtension(config: {
       const modelName = this?.name || this?.$name
       const startTime = Date.now()
 
-      // Try prebaked query first
       const queryKey = normalizeQuery(args)
       const prebakedQuery = QUERIES[modelName]?.[queryKey]
 
@@ -4513,12 +4523,10 @@ export function createExtension(config: {
       let prebaked = false
 
       if (prebakedQuery) {
-        // \u26A1 Use prebaked SQL
         sql = prebakedQuery.sql
         params = [...prebakedQuery.params, ...extractDynamicParams(args, prebakedQuery.dynamicKeys)]
         prebaked = true
       } else {
-        // \u{1F528} Fall back to runtime generation
         const model = MODELS.find((m: any) => m.name === modelName)
         
         if (!model) {
@@ -4586,6 +4594,9 @@ export function createExtension(config: {
 `;
 }
 function formatQueries(queries) {
+  if (queries.size === 0) {
+    return "{}";
+  }
   const entries = [];
   for (const [modelName, modelQueries] of queries) {
     const queryEntries = [];
@@ -4615,18 +4626,31 @@ function getDialectFromProvider(provider) {
     `Unsupported database provider: ${provider}. Supported: postgresql, postgres, sqlite`
   );
 }
+function getOutputDir(options) {
+  var _a, _b;
+  if ((_a = options.generator.output) == null ? void 0 : _a.value) {
+    return options.generator.output.value;
+  }
+  const clientGenerator = options.otherGenerators.find(
+    (g) => g.provider.value === "prisma-client-js"
+  );
+  if ((_b = clientGenerator == null ? void 0 : clientGenerator.output) == null ? void 0 : _b.value) {
+    const clientOutput = clientGenerator.output.value;
+    return path.join(path.resolve(path.dirname(clientOutput), ".."), "sql");
+  }
+  return "../node_modules/.prisma/sql";
+}
 generatorHelper.generatorHandler({
   onManifest() {
     return {
       version,
-      defaultOutput: "../node_modules/.prisma/client/sql",
+      defaultOutput: "../node_modules/.prisma/sql",
       prettyName: "prisma-sql-generator",
       requiresGenerators: ["prisma-client-js"]
     };
   },
   onGenerate(options) {
     return __async(this, null, function* () {
-      var _a;
       const { generator, dmmf, datasources } = options;
       if (!datasources || datasources.length === 0) {
         throw new Error("No datasource found in schema");
@@ -4643,7 +4667,7 @@ generatorHelper.generatorHandler({
         dialect,
         skipInvalid: generator.config.skipInvalid === "true"
       };
-      const outputDir = ((_a = generator.output) == null ? void 0 : _a.value) || "../node_modules/.prisma/client/sql";
+      const outputDir = getOutputDir(options);
       internals.logger.info(`Generating SQL client to ${outputDir}`);
       internals.logger.info(`Datasource: ${datasources[0].provider}`);
       internals.logger.info(`Dialect: ${config.dialect}`);