@smartive/graphql-magic 23.4.0-next.8 → 23.4.1

package/dist/bin/gqm.cjs

@@ -750,25 +750,9 @@ var generateKnexTables = (models) => {
 var import_code_block_writer2 = __toESM(require("code-block-writer"), 1);
 var import_knex_schema_inspector = require("knex-schema-inspector");
 var import_lowerFirst = __toESM(require("lodash/lowerFirst"), 1);
-
-// src/resolvers/arguments.ts
-var import_graphql3 = require("graphql");
-
-// src/resolvers/utils.ts
-var import_graphql4 = require("graphql");
-var import_isEqual = __toESM(require("lodash/isEqual"), 1);
-var getColumnName = (field) => field.kind === "relation" ? field.foreignKey || `${field.name}Id` : field.name;
-
-// src/resolvers/resolver.ts
-var import_cloneDeep2 = __toESM(require("lodash/cloneDeep"), 1);
-var import_flatMap = __toESM(require("lodash/flatMap"), 1);
-
-// src/migrations/generate.ts
 var MigrationGenerator = class {
-  constructor(knex2, models, parsedFunctions) {
+  constructor(knex2, models) {
     this.models = models;
-    this.parsedFunctions = parsedFunctions;
-    this.knex = knex2;
     this.schema = (0, import_knex_schema_inspector.SchemaInspector)(knex2);
   }
   // eslint-disable-next-line @typescript-eslint/dot-notation
@@ -781,7 +765,6 @@ var MigrationGenerator = class {
   uuidUsed;
   nowUsed;
   needsMigration = false;
-  knex;
   async generate() {
     const { writer, schema, models } = this;
     const enums = (await schema.knex("pg_type").where({ typtype: "e" }).select("typname")).map(({ typname }) => typname);
@@ -796,7 +779,6 @@ var MigrationGenerator = class {
       up,
       down
     );
-    await this.handleFunctions(up, down);
     for (const model of models.entities) {
       if (model.deleted) {
         up.push(() => {
@@ -858,7 +840,7 @@ var MigrationGenerator = class {
                   foreignKey: "id"
                 });
               }
-              for (const field of model.fields.filter(not(isInherited)).filter((f) => !(f.generateAs?.type === "expression"))) {
+              for (const field of model.fields.filter(not(isInherited))) {
                 this.column(field);
               }
             });
@@ -867,25 +849,29 @@ var MigrationGenerator = class {
             this.dropTable(model.name);
           });
         } else {
-          const fieldsToRename = model.fields.filter(not(isInherited)).filter(({ oldName }) => oldName);
-          this.renameFields(model.name, fieldsToRename, up, down);
+          this.renameFields(
+            model,
+            model.fields.filter(not(isInherited)).filter(({ oldName }) => oldName),
+            up,
+            down
+          );
           this.createFields(
             model,
             model.fields.filter(not(isInherited)).filter(
-              ({ name: name2, ...field }) => field.kind !== "custom" && !(field.generateAs?.type === "expression") && !this.getColumn(model.name, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
+              ({ name: name2, ...field }) => field.kind !== "custom" && !this.getColumn(model.name, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
             ),
             up,
             down
           );
           const rawExistingFields = model.fields.filter((field) => {
-            if (!field.generateAs || field.generateAs.type === "expression") {
+            if (!field.generateAs) {
               return false;
             }
             const col = this.getColumn(model.name, field.kind === "relation" ? `${field.name}Id` : field.name);
             if (!col) {
               return false;
             }
-            if (col.generation_expression !== field.generateAs.expression) {
+            if (col.generation_expression !== field.generateAs) {
               return true;
             }
             return this.hasChanged(model, field);
@@ -893,9 +879,7 @@ var MigrationGenerator = class {
           if (rawExistingFields.length) {
             this.updateFieldsRaw(model, rawExistingFields, up, down);
           }
-          const existingFields = model.fields.filter(
-            (field) => (!field.generateAs || field.generateAs.type === "expression") && this.hasChanged(model, field)
-          );
+          const existingFields = model.fields.filter((field) => !field.generateAs && this.hasChanged(model, field));
           this.updateFields(model, existingFields, up, down);
         }
         if (isUpdatableModel(model)) {
@@ -919,7 +903,7 @@ var MigrationGenerator = class {
                         writer.writeLine(`deleteRootType: row.deleteRootType,`);
                         writer.writeLine(`deleteRootId: row.deleteRootId,`);
                       }
-                      for (const { name: name2, kind } of model.fields.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === "expression"))) {
+                      for (const { name: name2, kind } of model.fields.filter(isUpdatableField)) {
                         const col = kind === "relation" ? `${name2}Id` : name2;
                         writer.writeLine(`${col}: row.${col},`);
                       }
@@ -933,14 +917,8 @@ var MigrationGenerator = class {
             });
           } else {
             const revisionTable = `${model.name}Revision`;
-            this.renameFields(
-              revisionTable,
-              model.fields.filter(isUpdatableField).filter(not(isInherited)).filter(({ oldName }) => oldName),
-              up,
-              down
-            );
             const missingRevisionFields = model.fields.filter(isUpdatableField).filter(
-              ({ name: name2, ...field }) => field.kind !== "custom" && !(field.generateAs?.type === "expression") && !this.getColumn(revisionTable, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
+              ({ name: name2, ...field }) => field.kind !== "custom" && !this.getColumn(revisionTable, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
             );
             this.createRevisionFields(model, missingRevisionFields, up, down);
             const revisionFieldsToRemove = model.fields.filter(
@@ -1006,13 +984,13 @@ var MigrationGenerator = class {
     this.migration("down", down.reverse());
     return writer.toString();
   }
-  renameFields(tableName, fields2, up, down) {
+  renameFields(model, fields2, up, down) {
     if (!fields2.length) {
       return;
     }
     up.push(() => {
       for (const field of fields2) {
-        this.alterTable(tableName, () => {
+        this.alterTable(model.name, () => {
           this.renameColumn(
             field.kind === "relation" ? `${field.oldName}Id` : get(field, "oldName"),
             field.kind === "relation" ? `${field.name}Id` : field.name
@@ -1022,7 +1000,7 @@ var MigrationGenerator = class {
     });
     down.push(() => {
       for (const field of fields2) {
-        this.alterTable(tableName, () => {
+        this.alterTable(model.name, () => {
           this.renameColumn(
             field.kind === "relation" ? `${field.name}Id` : field.name,
             field.kind === "relation" ? `${field.oldName}Id` : get(field, "oldName")
@@ -1031,7 +1009,7 @@ var MigrationGenerator = class {
       }
     });
     for (const field of fields2) {
-      summonByName(this.columns[tableName], field.kind === "relation" ? `${field.oldName}Id` : field.oldName).name = field.kind === "relation" ? `${field.name}Id` : field.name;
+      summonByName(this.columns[model.name], field.kind === "relation" ? `${field.oldName}Id` : field.oldName).name = field.kind === "relation" ? `${field.name}Id` : field.name;
     }
   }
   createFields(model, fields2, up, down) {
@@ -1043,9 +1021,6 @@ var MigrationGenerator = class {
       const updates = [];
       const postAlter = [];
       for (const field of fields2) {
-        if (field.generateAs?.type === "expression") {
-          continue;
-        }
         alter.push(() => this.column(field, { setNonNull: field.defaultValue !== void 0 }));
         if (field.generateAs) {
           continue;
@@ -1098,7 +1073,7 @@ var MigrationGenerator = class {
       });
     });
     if (isUpdatableModel(model)) {
-      const updatableFields = fields2.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === "expression"));
+      const updatableFields = fields2.filter(isUpdatableField);
       if (!updatableFields.length) {
         return;
       }
@@ -1146,7 +1121,7 @@ var MigrationGenerator = class {
       });
     });
     if (isUpdatableModel(model)) {
-      const updatableFields = fields2.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === "expression"));
+      const updatableFields = fields2.filter(isUpdatableField);
       if (!updatableFields.length) {
         return;
       }
@@ -1184,7 +1159,7 @@ var MigrationGenerator = class {
           writer.writeLine(`table.uuid('deleteRootId');`);
         }
       }
-      for (const field of model.fields.filter(and(isUpdatableField, not(isInherited))).filter((f) => !(f.generateAs?.type === "expression"))) {
+      for (const field of model.fields.filter(and(isUpdatableField, not(isInherited)))) {
         this.column(field, { setUnique: false, setDefault: false });
       }
     });
@@ -1198,19 +1173,14 @@ var MigrationGenerator = class {
             this.column(field, { setUnique: false, setNonNull: false, setDefault: false });
           }
         });
-        const revisionFieldsWithDataToCopy = missingRevisionFields.filter(
-          (field) => this.columns[model.name].find((col) => col.name === getColumnName(field)) || field.defaultValue !== void 0 || field.nonNull
-        );
-        if (revisionFieldsWithDataToCopy.length) {
-          this.writer.write(`await knex('${model.name}Revision').update(`).inlineBlock(() => {
-            for (const { name: name2, kind: type } of revisionFieldsWithDataToCopy) {
-              const col = type === "relation" ? `${name2}Id` : name2;
-              this.writer.write(
-                `${col}: knex.raw('(select "${col}" from "${model.name}" where "${model.name}".id = "${model.name}Revision"."${typeToField(model.name)}Id")'),`
-              ).newLine();
-            }
-          }).write(");").newLine().blankLine();
-        }
+        this.writer.write(`await knex('${model.name}Revision').update(`).inlineBlock(() => {
+          for (const { name: name2, kind: type } of missingRevisionFields) {
+            const col = type === "relation" ? `${name2}Id` : name2;
+            this.writer.write(
+              `${col}: knex.raw('(select "${col}" from "${model.name}" where "${model.name}".id = "${model.name}Revision"."${typeToField(model.name)}Id")'),`
+            ).newLine();
+          }
+        }).write(");").newLine().blankLine();
         const nonNullableMissingRevisionFields = missingRevisionFields.filter(({ nonNull: nonNull2 }) => nonNull2);
         if (nonNullableMissingRevisionFields.length) {
           this.alterTable(revisionTable, () => {
@@ -1266,7 +1236,7 @@ var MigrationGenerator = class {
     return this.writer.writeLine(`await knex.schema.renameTable('${from}', '${to}');`).blankLine();
   }
   renameColumn(from, to) {
-    this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
+    this.writer.writeLine(`table.renameColumn('${from}', '${to}')`);
   }
   value(value2) {
     if (typeof value2 === "string") {
@@ -1291,9 +1261,6 @@ var MigrationGenerator = class {
     };
     const kind = field.kind;
     if (field.generateAs) {
-      if (field.generateAs.type === "expression") {
-        throw new Error(`Expression fields cannot be created in SQL schema.`);
-      }
       let type = "";
       switch (kind) {
         case void 0:
@@ -1302,9 +1269,6 @@ var MigrationGenerator = class {
             case "Float":
               type = `decimal(${field.precision ?? "undefined"}, ${field.scale ?? "undefined"})`;
               break;
-            case "Boolean":
-              type = "boolean";
-              break;
             default:
               throw new Error(`Generated columns of kind ${kind} and type ${field.type} are not supported yet.`);
           }
@@ -1324,10 +1288,10 @@ var MigrationGenerator = class {
             this.writer.write(`, ALTER COLUMN "${name2}" DROP NOT NULL`);
           }
         }
-        this.writer.write(`, ALTER COLUMN "${name2}" SET EXPRESSION AS (${field.generateAs.expression})`);
+        this.writer.write(`, ALTER COLUMN "${name2}" SET EXPRESSION AS (${field.generateAs})`);
       } else {
         this.writer.write(
-          `${alter ? "ALTER" : "ADD"} COLUMN "${name2}" ${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs.expression}) STORED`
+          `${alter ? "ALTER" : "ADD"} COLUMN "${name2}" ${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs}) STORED`
         );
       }
       return;
@@ -1351,9 +1315,6 @@ var MigrationGenerator = class {
     };
     const kind = field.kind;
     if (field.generateAs) {
-      if (field.generateAs.type === "expression") {
-        throw new Error(`Expression fields cannot be created in SQL schema.`);
-      }
       let type = "";
       switch (kind) {
         case void 0:
@@ -1362,9 +1323,6 @@ var MigrationGenerator = class {
             case "Float":
               type = `decimal(${field.precision ?? "undefined"}, ${field.scale ?? "undefined"})`;
               break;
-            case "Boolean":
-              type = "boolean";
-              break;
             default:
               throw new Error(`Generated columns of kind ${kind} and type ${field.type} are not supported yet.`);
           }
@@ -1373,7 +1331,7 @@ var MigrationGenerator = class {
           throw new Error(`Generated columns of kind ${kind} are not supported yet.`);
       }
       this.writer.write(
-        `table.specificType('${name2}', '${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs.expression}) ${field.generateAs.type === "virtual" ? "VIRTUAL" : "STORED"}')`
+        `table.specificType('${name2}', '${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs}) STORED')`
       );
       if (alter) {
         this.writer.write(".alter()");
@@ -1471,17 +1429,14 @@ var MigrationGenerator = class {
     return this.columns[tableName].find((col) => col.name === columnName);
   }
   hasChanged(model, field) {
-    if (field.generateAs?.type === "expression") {
-      return false;
-    }
     const col = this.getColumn(model.name, field.kind === "relation" ? `${field.name}Id` : field.name);
     if (!col) {
       return false;
     }
     if (field.generateAs) {
-      if (col.generation_expression !== field.generateAs.expression) {
+      if (col.generation_expression !== field.generateAs) {
         throw new Error(
-          `Column ${col.name} has specific type ${col.generation_expression} but expected ${field.generateAs.expression}`
+          `Column ${col.name} has specific type ${col.generation_expression} but expected ${field.generateAs}`
         );
       }
     }
@@ -1523,182 +1478,6 @@ var MigrationGenerator = class {
     }
     return false;
   }
-  normalizeFunctionBody(body) {
-    return body.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\s*,\s*/g, ",").trim();
-  }
-  normalizeAggregateDefinition(definition) {
-    let normalized = definition.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\s*,\s*/g, ",").trim();
-    const initCondMatch = normalized.match(/INITCOND\s*=\s*([^,)]+)/i);
-    if (initCondMatch) {
-      const initCondValue = initCondMatch[1].trim();
-      const unquoted = initCondValue.replace(/^['"]|['"]$/g, "");
-      if (/^\d+$/.test(unquoted)) {
-        normalized = normalized.replace(/INITCOND\s*=\s*[^,)]+/i, `INITCOND = '${unquoted}'`);
-      }
-    }
-    return normalized;
-  }
-  extractFunctionBody(definition) {
-    const dollarQuoteMatch = definition.match(/AS\s+\$([^$]*)\$([\s\S]*?)\$\1\$/i);
-    if (dollarQuoteMatch) {
-      return dollarQuoteMatch[2].trim();
-    }
-    const bodyMatch = definition.match(/AS\s+\$\$([\s\S]*?)\$\$/i) || definition.match(/AS\s+['"]([\s\S]*?)['"]/i);
-    if (bodyMatch) {
-      return bodyMatch[1].trim();
-    }
-    return definition;
-  }
-  async getDatabaseFunctions() {
-    const regularFunctions = await this.knex.raw(`
-      SELECT 
-        p.proname as name,
-        pg_get_function_identity_arguments(p.oid) as arguments,
-        pg_get_functiondef(p.oid) as definition,
-        false as is_aggregate
-      FROM pg_proc p
-      JOIN pg_namespace n ON p.pronamespace = n.oid
-      WHERE n.nspname = 'public'
-      AND NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid)
-      ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-    `);
-    const aggregateFunctions = await this.knex.raw(`
-      SELECT 
-        p.proname as name,
-        pg_get_function_identity_arguments(p.oid) as arguments,
-        a.aggtransfn::regproc::text as trans_func,
-        a.aggfinalfn::regproc::text as final_func,
-        a.agginitval as init_val,
-        pg_catalog.format_type(a.aggtranstype, NULL) as state_type,
-        true as is_aggregate
-      FROM pg_proc p
-      JOIN pg_aggregate a ON p.oid = a.aggfnoid
-      JOIN pg_namespace n ON p.pronamespace = n.oid
-      WHERE n.nspname = 'public'
-      ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-    `);
-    const result = [];
-    for (const row of regularFunctions.rows || []) {
-      const definition = row.definition || "";
-      const name2 = row.name || "";
-      const argumentsStr = row.arguments || "";
-      if (!definition) {
-        continue;
-      }
-      const signature = `${name2}(${argumentsStr})`;
-      const body = this.normalizeFunctionBody(this.extractFunctionBody(definition));
-      result.push({
-        name: name2,
-        signature,
-        body,
-        isAggregate: false,
-        definition
-      });
-    }
-    for (const row of aggregateFunctions.rows || []) {
-      const name2 = row.name || "";
-      const argumentsStr = row.arguments || "";
-      const transFunc = row.trans_func || "";
-      const finalFunc = row.final_func || "";
-      const initVal = row.init_val;
-      const stateType = row.state_type || "";
-      const signature = `${name2}(${argumentsStr})`;
-      let aggregateDef = `CREATE AGGREGATE ${name2}(${argumentsStr}) (`;
-      aggregateDef += `SFUNC = ${transFunc}, STYPE = ${stateType}`;
-      if (finalFunc) {
-        aggregateDef += `, FINALFUNC = ${finalFunc}`;
-      }
-      if (initVal !== null && initVal !== void 0) {
-        let initValStr;
-        if (typeof initVal === "string") {
-          initValStr = `'${initVal}'`;
-        } else {
-          const numStr = String(initVal);
-          initValStr = /^\d+$/.test(numStr) ? `'${numStr}'` : numStr;
-        }
-        aggregateDef += `, INITCOND = ${initValStr}`;
-      }
-      aggregateDef += ");";
-      result.push({
-        name: name2,
-        signature,
-        body: this.normalizeAggregateDefinition(aggregateDef),
-        isAggregate: true,
-        definition: aggregateDef
-      });
-    }
-    return result;
-  }
-  async handleFunctions(up, down) {
-    if (!this.parsedFunctions || this.parsedFunctions.length === 0) {
-      return;
-    }
-    const definedFunctions = this.parsedFunctions;
-    const dbFunctions = await this.getDatabaseFunctions();
-    const dbFunctionsBySignature = /* @__PURE__ */ new Map();
-    for (const func of dbFunctions) {
-      dbFunctionsBySignature.set(func.signature, func);
-    }
-    const definedFunctionsBySignature = /* @__PURE__ */ new Map();
-    for (const func of definedFunctions) {
-      definedFunctionsBySignature.set(func.signature, func);
-    }
-    const functionsToRestore = [];
-    for (const definedFunc of definedFunctions) {
-      const dbFunc = dbFunctionsBySignature.get(definedFunc.signature);
-      if (!dbFunc) {
-        up.push(() => {
-          this.writer.writeLine(`await knex.raw(\`${definedFunc.fullDefinition.replace(/`/g, "\\`")}\`);`).blankLine();
-        });
-        down.push(() => {
-          const isAggregate = definedFunc.isAggregate;
-          const dropMatch = definedFunc.fullDefinition.match(/CREATE\s+(OR\s+REPLACE\s+)?(FUNCTION|AGGREGATE)\s+([^(]+)\(/i);
-          if (dropMatch) {
-            const functionName = dropMatch[3].trim();
-            const argsMatch = definedFunc.fullDefinition.match(
-              /CREATE\s+(OR\s+REPLACE\s+)?(FUNCTION|AGGREGATE)\s+[^(]+\(([^)]*)\)/i
-            );
-            const args2 = argsMatch ? argsMatch[3].trim() : "";
-            const dropType = isAggregate ? "AGGREGATE" : "FUNCTION";
-            this.writer.writeLine(`await knex.raw(\`DROP ${dropType} IF EXISTS ${functionName}${args2 ? `(${args2})` : ""}\`);`).blankLine();
-          }
-        });
-      } else {
-        const dbBody = dbFunc.isAggregate ? this.normalizeAggregateDefinition(dbFunc.body) : this.normalizeFunctionBody(dbFunc.body);
-        const definedBody = definedFunc.isAggregate ? this.normalizeAggregateDefinition(definedFunc.body) : this.normalizeFunctionBody(definedFunc.body);
-        if (dbBody !== definedBody) {
-          const oldDefinition = dbFunc.definition || dbFunc.body;
-          up.push(() => {
-            this.writer.writeLine(`await knex.raw(\`${definedFunc.fullDefinition.replace(/`/g, "\\`")}\`);`).blankLine();
-          });
-          down.push(() => {
-            if (oldDefinition) {
-              this.writer.writeLine(`await knex.raw(\`${oldDefinition.replace(/`/g, "\\`")}\`);`).blankLine();
-            }
-          });
-        }
-      }
-    }
-    for (const dbFunc of dbFunctions) {
-      if (!definedFunctionsBySignature.has(dbFunc.signature)) {
-        const definition = dbFunc.definition || dbFunc.body;
-        if (definition) {
-          functionsToRestore.push({ func: dbFunc, definition });
-          down.push(() => {
-            const argsMatch = dbFunc.signature.match(/\(([^)]*)\)/);
-            const args2 = argsMatch ? argsMatch[1] : "";
-            const dropType = dbFunc.isAggregate ? "AGGREGATE" : "FUNCTION";
-            this.writer.writeLine(`await knex.raw(\`DROP ${dropType} IF EXISTS ${dbFunc.name}${args2 ? `(${args2})` : ""}\`);`).blankLine();
-          });
-        }
-      }
-    }
-    for (const { definition } of functionsToRestore) {
-      up.push(() => {
-        this.writer.writeLine(`await knex.raw(\`${definition.replace(/`/g, "\\`")}\`);`).blankLine();
-      });
-    }
-  }
 };
 var getMigrationDate = () => {
   const date = /* @__PURE__ */ new Date();
@@ -1711,258 +1490,21 @@ var getMigrationDate = () => {
   return `${year}${month}${day}${hours}${minutes}${seconds}`;
 };
 
-// src/migrations/generate-functions.ts
-var generateFunctionsFromDatabase = async (knex2) => {
-  const regularFunctions = await knex2.raw(`
-    SELECT 
-      pg_get_functiondef(p.oid) as definition
-    FROM pg_proc p
-    JOIN pg_namespace n ON p.pronamespace = n.oid
-    WHERE n.nspname = 'public'
-    AND NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid)
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-  const aggregateFunctions = await knex2.raw(`
-    SELECT 
-      p.proname as name,
-      pg_get_function_identity_arguments(p.oid) as arguments,
-      a.aggtransfn::regproc::text as trans_func,
-      a.aggfinalfn::regproc::text as final_func,
-      a.agginitval as init_val,
-      pg_catalog.format_type(a.aggtranstype, NULL) as state_type
-    FROM pg_proc p
-    JOIN pg_aggregate a ON p.oid = a.aggfnoid
-    JOIN pg_namespace n ON p.pronamespace = n.oid
-    WHERE n.nspname = 'public'
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-  const functions = [];
-  for (const row of regularFunctions.rows || []) {
-    if (row.definition) {
-      functions.push(row.definition.trim());
-    }
-  }
-  for (const row of aggregateFunctions.rows || []) {
-    const name2 = row.name || "";
-    const argumentsStr = row.arguments || "";
-    const transFunc = row.trans_func || "";
-    const finalFunc = row.final_func || "";
-    const initVal = row.init_val;
-    const stateType = row.state_type || "";
-    if (!name2 || !transFunc || !stateType) {
-      continue;
-    }
-    let aggregateDef = `CREATE AGGREGATE ${name2}(${argumentsStr}) (
-`;
-    aggregateDef += `  SFUNC = ${transFunc},
-`;
-    aggregateDef += `  STYPE = ${stateType}`;
-    if (finalFunc) {
-      aggregateDef += `,
-  FINALFUNC = ${finalFunc}`;
-    }
-    if (initVal !== null && initVal !== void 0) {
-      const initValStr = typeof initVal === "string" ? `'${initVal}'` : String(initVal);
-      aggregateDef += `,
-  INITCOND = ${initValStr}`;
-    }
-    aggregateDef += "\n);";
-    functions.push(aggregateDef);
-  }
-  if (functions.length === 0) {
-    return `export const functions: string[] = [];
-`;
-  }
-  const functionsArrayString = functions.map((func) => `  ${JSON.stringify(func)}`).join(",\n");
-  return `export const functions: string[] = [
-${functionsArrayString},
-];
-`;
-};
-
-// src/migrations/update-functions.ts
-var normalizeWhitespace = (str) => {
-  return str.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\s*,\s*/g, ",").replace(/\s*;\s*/g, ";").trim();
-};
-var normalizeFunctionBody = (body) => {
-  return normalizeWhitespace(body);
-};
-var extractFunctionBody = (definition) => {
-  const dollarQuoteMatch = definition.match(/AS\s+\$([^$]*)\$([\s\S]*?)\$\1\$/i);
-  if (dollarQuoteMatch) {
-    return dollarQuoteMatch[2].trim();
-  }
-  const bodyMatch = definition.match(/AS\s+\$\$([\s\S]*?)\$\$/i) || definition.match(/AS\s+['"]([\s\S]*?)['"]/i);
-  if (bodyMatch) {
-    return bodyMatch[1].trim();
-  }
-  return definition;
-};
-var getDatabaseFunctions = async (knex2) => {
-  const regularFunctions = await knex2.raw(`
-    SELECT 
-      p.proname as name,
-      pg_get_function_identity_arguments(p.oid) as arguments,
-      pg_get_functiondef(p.oid) as definition,
-      false as is_aggregate
-    FROM pg_proc p
-    JOIN pg_namespace n ON p.pronamespace = n.oid
-    WHERE n.nspname = 'public'
-    AND NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid)
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-  const aggregateFunctions = await knex2.raw(`
-    SELECT 
-      p.proname as name,
-      pg_get_function_identity_arguments(p.oid) as arguments,
-      a.aggtransfn::regproc::text as trans_func,
-      a.aggfinalfn::regproc::text as final_func,
-      a.agginitval as init_val,
-      pg_catalog.format_type(a.aggtranstype, NULL) as state_type,
-      true as is_aggregate
-    FROM pg_proc p
-    JOIN pg_aggregate a ON p.oid = a.aggfnoid
-    JOIN pg_namespace n ON p.pronamespace = n.oid
-    WHERE n.nspname = 'public'
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-  const result = [];
-  for (const row of regularFunctions.rows || []) {
-    const definition = row.definition || "";
-    const name2 = row.name || "";
-    const argumentsStr = row.arguments || "";
-    if (!definition) {
-      continue;
-    }
-    const signature = `${name2}(${argumentsStr})`;
-    const body = normalizeFunctionBody(extractFunctionBody(definition));
-    result.push({
-      name: name2,
-      signature,
-      body,
-      isAggregate: false,
-      definition
-    });
-  }
-  for (const row of aggregateFunctions.rows || []) {
-    const name2 = row.name || "";
-    const argumentsStr = row.arguments || "";
-    const transFunc = row.trans_func || "";
-    const finalFunc = row.final_func || "";
-    const initVal = row.init_val;
-    const stateType = row.state_type || "";
-    const signature = `${name2}(${argumentsStr})`;
-    let aggregateDef = `CREATE AGGREGATE ${name2}(${argumentsStr}) (`;
-    aggregateDef += `SFUNC = ${transFunc}, STYPE = ${stateType}`;
-    if (finalFunc) {
-      aggregateDef += `, FINALFUNC = ${finalFunc}`;
-    }
-    if (initVal !== null && initVal !== void 0) {
-      const initValStr = typeof initVal === "string" ? `'${initVal}'` : String(initVal);
-      aggregateDef += `, INITCOND = ${initValStr}`;
-    }
-    aggregateDef += ");";
-    result.push({
-      name: name2,
-      signature,
-      body: normalizeFunctionBody(aggregateDef),
-      isAggregate: true,
-      definition: aggregateDef
-    });
-  }
-  return result;
-};
-var compareFunctions = (defined, db) => {
-  const definedBody = normalizeFunctionBody(defined.body);
-  const dbBody = normalizeFunctionBody(db.body);
-  if (definedBody !== dbBody) {
-    const definedPreview = definedBody.length > 200 ? `${definedBody.substring(0, 200)}...` : definedBody;
-    const dbPreview = dbBody.length > 200 ? `${dbBody.substring(0, 200)}...` : dbBody;
-    return {
-      changed: true,
-      diff: `Definition changed:
-  File: ${definedPreview}
-  DB:   ${dbPreview}`
-    };
-  }
-  return { changed: false };
-};
-var updateFunctions = async (knex2, parsedFunctions) => {
-  if (parsedFunctions.length === 0) {
-    return;
-  }
-  const definedFunctions = parsedFunctions;
-  const dbFunctions = await getDatabaseFunctions(knex2);
-  const dbFunctionsBySignature = /* @__PURE__ */ new Map();
-  for (const func of dbFunctions) {
-    dbFunctionsBySignature.set(func.signature, func);
-  }
-  console.info(`Found ${definedFunctions.length} function(s) in file, ${dbFunctions.length} function(s) in database.`);
-  let updatedCount = 0;
-  let skippedCount = 0;
-  for (const definedFunc of definedFunctions) {
-    const dbFunc = dbFunctionsBySignature.get(definedFunc.signature);
-    if (!dbFunc) {
-      try {
-        await knex2.raw(definedFunc.fullDefinition);
-        console.info(`\u2713 Created ${definedFunc.isAggregate ? "aggregate" : "function"}: ${definedFunc.signature}`);
-        updatedCount++;
-      } catch (error) {
-        console.error(
-          `\u2717 Failed to create ${definedFunc.isAggregate ? "aggregate" : "function"} ${definedFunc.signature}:`,
-          error.message
-        );
-        throw error;
-      }
-    } else {
-      const comparison = compareFunctions(definedFunc, dbFunc);
-      if (comparison.changed) {
-        console.info(`
-\u26A0 ${definedFunc.isAggregate ? "Aggregate" : "Function"} ${definedFunc.signature} has changes:`);
-        if (comparison.diff) {
-          console.info(comparison.diff);
-        }
-        try {
-          if (definedFunc.isAggregate) {
-            const dropMatch = definedFunc.fullDefinition.match(/CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE\s+([^(]+)\(/i);
-            if (dropMatch) {
-              const functionName = dropMatch[2].trim();
-              const argsMatch = definedFunc.fullDefinition.match(/CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE\s+[^(]+\(([^)]*)\)/i);
-              const args2 = argsMatch ? argsMatch[2].trim() : "";
-              await knex2.raw(`DROP AGGREGATE IF EXISTS ${functionName}${args2 ? `(${args2})` : ""}`);
-            }
-          }
-          await knex2.raw(definedFunc.fullDefinition);
-          console.info(`\u2713 Updated ${definedFunc.isAggregate ? "aggregate" : "function"}: ${definedFunc.signature}
-`);
-          updatedCount++;
-        } catch (error) {
-          console.error(
-            `\u2717 Failed to update ${definedFunc.isAggregate ? "aggregate" : "function"} ${definedFunc.signature}:`,
-            error.message
-          );
-          throw error;
-        }
-      } else {
-        console.info(
-          `\u25CB Skipped ${definedFunc.isAggregate ? "aggregate" : "function"} (unchanged): ${definedFunc.signature}`
-        );
-        skippedCount++;
-      }
-    }
-  }
-  console.info(`
-Summary: ${updatedCount} updated, ${skippedCount} skipped`);
-  if (updatedCount > 0) {
-    console.info("Functions updated successfully.");
-  } else {
-    console.info("All functions are up to date.");
-  }
-};
+// src/resolvers/utils.ts
+var import_graphql3 = require("graphql");
+var import_isEqual = __toESM(require("lodash/isEqual"), 1);
+var getColumnName = (field) => field.kind === "relation" ? field.foreignKey || `${field.name}Id` : field.name;
 
 // src/permissions/generate.ts
 var ACTIONS = ["READ", "CREATE", "UPDATE", "DELETE", "RESTORE", "LINK"];
 
+// src/resolvers/arguments.ts
+var import_graphql4 = require("graphql");
+
+// src/resolvers/resolver.ts
+var import_cloneDeep2 = __toESM(require("lodash/cloneDeep"), 1);
+var import_flatMap = __toESM(require("lodash/flatMap"), 1);
+
 // src/schema/generate.ts
 var import_graphql6 = require("graphql");
 
@@ -2540,14 +2082,6 @@ var DEFAULTS = {
       ensureFileExists(path, EMPTY_MODELS);
     }
   },
-  functionsPath: {
-    question: "What is the PostgreSQL functions file path?",
-    defaultValue: "src/config/functions.ts",
-    init: (path) => {
-      ensureFileExists(path, `export const functions: string[] = [];
-`);
-    }
-  },
   generatedFolderPath: {
     question: "What is the path for generated stuff?",
     defaultValue: "src/generated",
@@ -2727,8 +2261,7 @@ var generateGraphqlClientTypes = async () => {
   });
 };
 
-// src/bin/gqm/parse-functions.ts
-var import_fs2 = require("fs");
+// src/bin/gqm/parse-knexfile.ts
 var import_ts_morph4 = require("ts-morph");
 
 // src/bin/gqm/static-eval.ts
@@ -2821,6 +2354,72 @@ var VISITOR = {
   }),
   [import_ts_morph2.SyntaxKind.SpreadElement]: (node, context) => staticEval(node.getExpression(), context),
   [import_ts_morph2.SyntaxKind.SpreadAssignment]: (node, context) => staticEval(node.getExpression(), context),
+  [import_ts_morph2.SyntaxKind.ImportSpecifier]: (node, context) => {
+    const nameNode = node.getNameNode();
+    const name2 = nameNode.getText();
+    if (name2 in KNOWN_IDENTIFIERS) {
+      return KNOWN_IDENTIFIERS[name2];
+    }
+    if (nameNode instanceof import_ts_morph2.StringLiteral) {
+      throw new Error(`Cannot handle computed import specifier: ${name2}. Only static imports are supported.`);
+    }
+    const definitions = nameNode.getDefinitionNodes();
+    let externalDefinition = definitions.find((d) => d.compilerNode !== node.compilerNode);
+    if (!externalDefinition) {
+      const importDeclaration = node.getImportDeclaration();
+      let sourceFile = importDeclaration.getModuleSpecifierSourceFile();
+      if (!sourceFile) {
+        const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+        const project = node.getProject();
+        if (moduleSpecifier.startsWith("@/")) {
+          const suffix = moduleSpecifier.substring(2);
+          sourceFile = project.getSourceFiles().find((sf) => {
+            const filePath = sf.getFilePath();
+            return filePath.endsWith(`/${suffix}.ts`) || filePath.endsWith(`/${suffix}.tsx`) || filePath.endsWith(`/${suffix}/index.ts`) || filePath.endsWith(`/${suffix}/index.tsx`);
+          });
+          if (!sourceFile) {
+            const candidates = [
+              `src/${suffix}.ts`,
+              `src/${suffix}.tsx`,
+              `src/${suffix}/index.ts`,
+              `src/${suffix}/index.tsx`
+            ];
+            for (const candidate of candidates) {
+              try {
+                const added = project.addSourceFileAtPathIfExists(candidate);
+                if (added) {
+                  sourceFile = added;
+                  break;
+                }
+              } catch {
+              }
+            }
+          }
+        }
+      }
+      if (sourceFile) {
+        const localName = node.getName();
+        const propertyName = node.compilerNode.propertyName?.getText();
+        const exportedName = propertyName ?? localName;
+        const exportedDeclarations = sourceFile.getExportedDeclarations();
+        const declarations = exportedDeclarations.get(exportedName);
+        const declaration = declarations?.[0];
+        if (declaration) {
+          externalDefinition = declaration;
+        }
+      }
+    }
+    if (externalDefinition && externalDefinition.getKind() === import_ts_morph2.SyntaxKind.ImportSpecifier) {
+      return staticEval(externalDefinition, context);
+    }
+    if (!externalDefinition) {
+      const importDeclaration = node.getImportDeclaration();
+      throw new Error(
+        `No definition node found for import specifier '${name2}' imported from '${importDeclaration.getModuleSpecifierValue()}'.`
+      );
+    }
+    return staticEval(externalDefinition, context);
+  },
   [import_ts_morph2.SyntaxKind.Identifier]: (node, context) => {
     const identifierName = node.getText();
     if (identifierName in KNOWN_IDENTIFIERS) {
@@ -3047,114 +2646,11 @@ var findDeclaration = (syntaxList, name2) => {
   }
 };
 
-// src/bin/gqm/parse-functions.ts
-var normalizeWhitespace2 = (str) => {
-  return str.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\s*,\s*/g, ",").replace(/\s*;\s*/g, ";").trim();
-};
-var normalizeFunctionBody2 = (body) => {
-  return normalizeWhitespace2(body);
-};
-var normalizeAggregateDefinition = (definition) => {
-  let normalized = normalizeWhitespace2(definition);
-  const initCondMatch = normalized.match(/INITCOND\s*=\s*([^,)]+)/i);
-  if (initCondMatch) {
-    const initCondValue = initCondMatch[1].trim();
-    const unquoted = initCondValue.replace(/^['"]|['"]$/g, "");
-    if (/^\d+$/.test(unquoted)) {
-      normalized = normalized.replace(/INITCOND\s*=\s*[^,)]+/i, `INITCOND = '${unquoted}'`);
-    }
-  }
-  return normalized;
-};
-var extractFunctionSignature = (definition, isAggregate) => {
-  if (isAggregate) {
-    const createMatch2 = definition.match(/CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE\s+([^(]+)\(/i);
-    if (!createMatch2) {
-      return null;
-    }
-    const functionNamePart2 = createMatch2[2].trim().replace(/^[^.]+\./, "");
-    const argsMatch = definition.match(/CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE\s+[^(]+\(([^)]*)\)/i);
-    const args3 = argsMatch ? argsMatch[2].trim() : "";
-    return `${functionNamePart2}(${args3})`;
-  }
-  const createMatch = definition.match(/CREATE\s+(OR\s+REPLACE\s+)?FUNCTION\s+([^(]+)\(/i);
-  if (!createMatch) {
-    return null;
-  }
-  const functionNamePart = createMatch[2].trim().replace(/^[^.]+\./, "");
-  const fullArgsMatch = definition.match(
-    /CREATE\s+(OR\s+REPLACE\s+)?FUNCTION\s+[^(]+\(([\s\S]*?)\)\s*(RETURNS|LANGUAGE|AS|STRICT|IMMUTABLE|STABLE|VOLATILE|SECURITY)/i
-  );
-  if (!fullArgsMatch) {
-    return null;
-  }
-  const argsSection = fullArgsMatch[2].trim();
-  const args2 = argsSection.split(/\s*,\s*/).map((arg) => {
-    return arg.trim().replace(/\s+/g, " ");
-  }).join(", ");
-  return `${functionNamePart}(${args2})`;
-};
-var extractFunctionBody2 = (definition) => {
-  const dollarQuoteMatch = definition.match(/AS\s+\$([^$]*)\$([\s\S]*?)\$\1\$/i);
-  if (dollarQuoteMatch) {
-    return dollarQuoteMatch[2].trim();
-  }
-  const bodyMatch = definition.match(/AS\s+\$\$([\s\S]*?)\$\$/i) || definition.match(/AS\s+['"]([\s\S]*?)['"]/i);
-  if (bodyMatch) {
-    return bodyMatch[1].trim();
-  }
-  return definition;
-};
-var parseFunctionsFile = (filePath) => {
-  if (!(0, import_fs2.existsSync)(filePath)) {
-    return [];
-  }
-  const project = new import_ts_morph4.Project({
-    manipulationSettings: {
-      indentationText: import_ts_morph4.IndentationText.TwoSpaces
-    }
-  });
-  const sourceFile = project.addSourceFileAtPath(filePath);
-  try {
-    const functionsDeclaration = findDeclarationInFile(sourceFile, "functions");
-    const functionsArray = staticEval(functionsDeclaration, {});
-    if (!Array.isArray(functionsArray)) {
-      return [];
-    }
-    const parsedFunctions = [];
-    for (const definition of functionsArray) {
-      if (!definition || typeof definition !== "string") {
-        continue;
-      }
-      const trimmedDefinition = definition.trim();
-      const isAggregate = /CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE/i.test(trimmedDefinition);
-      const signature = extractFunctionSignature(trimmedDefinition, isAggregate);
-      if (!signature) {
-        continue;
-      }
-      const nameMatch = signature.match(/^([^(]+)\(/);
-      const name2 = nameMatch ? nameMatch[1].trim().split(".").pop() || "" : "";
-      const body = isAggregate ? trimmedDefinition : extractFunctionBody2(trimmedDefinition);
-      parsedFunctions.push({
-        name: name2,
-        signature,
-        body: isAggregate ? normalizeAggregateDefinition(body) : normalizeFunctionBody2(body),
-        fullDefinition: trimmedDefinition,
-        isAggregate
-      });
-    }
-    return parsedFunctions;
-  } catch (error) {
-    return [];
-  }
-};
-
 // src/bin/gqm/parse-knexfile.ts
-var import_ts_morph5 = require("ts-morph");
 var parseKnexfile = async () => {
-  const project = new import_ts_morph5.Project({
+  const project = new import_ts_morph4.Project({
     manipulationSettings: {
-      indentationText: import_ts_morph5.IndentationText.TwoSpaces
+      indentationText: import_ts_morph4.IndentationText.TwoSpaces
     }
   });
   const knexfilePath = await getSetting("knexfilePath");
@@ -3166,11 +2662,11 @@ var parseKnexfile = async () => {
 };
 
 // src/bin/gqm/parse-models.ts
-var import_ts_morph6 = require("ts-morph");
+var import_ts_morph5 = require("ts-morph");
 var parseModels = async () => {
-  const project = new import_ts_morph6.Project({
+  const project = new import_ts_morph5.Project({
     manipulationSettings: {
-      indentationText: import_ts_morph6.IndentationText.TwoSpaces
+      indentationText: import_ts_morph5.IndentationText.TwoSpaces
     }
   });
   const modelsPath = await getSetting("modelsPath");
@@ -3183,11 +2679,11 @@ var parseModels = async () => {
 };
 
 // src/bin/gqm/permissions.ts
-var import_ts_morph7 = require("ts-morph");
+var import_ts_morph6 = require("ts-morph");
 var generatePermissionTypes = (models) => {
-  const project = new import_ts_morph7.Project({
+  const project = new import_ts_morph6.Project({
     manipulationSettings: {
-      indentationText: import_ts_morph7.IndentationText.TwoSpaces
+      indentationText: import_ts_morph6.IndentationText.TwoSpaces
     }
   });
   const sourceFile = project.createSourceFile("permissions.ts", "", {
@@ -3290,9 +2786,7 @@ import_commander.program.command("generate-migration [<name>] [<date>]").descrip
   const db = (0, import_knex.default)(knexfile);
   try {
     const models = await parseModels();
-    const functionsPath = await getSetting("functionsPath");
-    const parsedFunctions = parseFunctionsFile(functionsPath);
-    const migrations = await new MigrationGenerator(db, models, parsedFunctions).generate();
+    const migrations = await new MigrationGenerator(db, models).generate();
     writeToFile(`migrations/${date || getMigrationDate()}_${name2}.ts`, migrations);
   } finally {
     await db.destroy();
@@ -3303,9 +2797,7 @@ import_commander.program.command("check-needs-migration").description("Check if
   const db = (0, import_knex.default)(knexfile);
   try {
     const models = await parseModels();
-    const functionsPath = await getSetting("functionsPath");
-    const parsedFunctions = parseFunctionsFile(functionsPath);
-    const mg = new MigrationGenerator(db, models, parsedFunctions);
+    const mg = new MigrationGenerator(db, models);
     await mg.generate();
     if (mg.needsMigration) {
       console.error("Migration is needed.");
@@ -3315,31 +2807,8 @@ import_commander.program.command("check-needs-migration").description("Check if
     await db.destroy();
   }
 });
-import_commander.program.command("generate-functions").description("Generate functions.ts file from database").action(async () => {
-  const knexfile = await parseKnexfile();
-  const db = (0, import_knex.default)(knexfile);
-  try {
-    const functionsPath = await getSetting("functionsPath");
-    const functions = await generateFunctionsFromDatabase(db);
-    writeToFile(functionsPath, functions);
-  } finally {
-    await db.destroy();
-  }
-});
-import_commander.program.command("update-functions").description("Update database functions from functions.ts file").action(async () => {
-  const knexfile = await parseKnexfile();
-  const db = (0, import_knex.default)(knexfile);
-  try {
-    const functionsPath = await getSetting("functionsPath");
-    const parsedFunctions = parseFunctionsFile(functionsPath);
-    await updateFunctions(db, parsedFunctions);
-  } finally {
-    await db.destroy();
-  }
-});
-import_commander.program.command("*").description("Invalid command").action((command) => {
-  console.error(`Invalid command: ${command}
-See --help for a list of available commands.`);
+import_commander.program.command("*", { noHelp: true }).description("Invalid command").action(() => {
+  console.error("Invalid command: %s\nSee --help for a list of available commands.", import_commander.program.args.join(" "));
   process.exit(1);
 });
 import_commander.program.parse(process.argv);