@smartive/graphql-magic 23.4.1 → 23.5.0-next.1

package/dist/bin/gqm.cjs

@@ -750,9 +750,25 @@ 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) {
+  constructor(knex2, models, parsedFunctions) {
     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
@@ -765,6 +781,7 @@ 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);
@@ -779,6 +796,7 @@ var MigrationGenerator = class {
       up,
       down
     );
+    await this.handleFunctions(up, down);
     for (const model of models.entities) {
       if (model.deleted) {
         up.push(() => {
@@ -840,7 +858,7 @@ var MigrationGenerator = class {
                   foreignKey: "id"
                 });
               }
-              for (const field of model.fields.filter(not(isInherited))) {
+              for (const field of model.fields.filter(not(isInherited)).filter((f) => !(f.generateAs?.type === "expression"))) {
                 this.column(field);
               }
             });
@@ -849,29 +867,25 @@ var MigrationGenerator = class {
             this.dropTable(model.name);
           });
         } else {
-          this.renameFields(
-            model,
-            model.fields.filter(not(isInherited)).filter(({ oldName }) => oldName),
-            up,
-            down
-          );
+          const fieldsToRename = model.fields.filter(not(isInherited)).filter(({ oldName }) => oldName);
+          this.renameFields(model.name, fieldsToRename, up, down);
           this.createFields(
             model,
             model.fields.filter(not(isInherited)).filter(
-              ({ name: name2, ...field }) => field.kind !== "custom" && !this.getColumn(model.name, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
+              ({ name: name2, ...field }) => field.kind !== "custom" && !(field.generateAs?.type === "expression") && !this.getColumn(model.name, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
             ),
             up,
             down
           );
           const rawExistingFields = model.fields.filter((field) => {
-            if (!field.generateAs) {
+            if (!field.generateAs || 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 (col.generation_expression !== field.generateAs) {
+            if (col.generation_expression !== field.generateAs.expression) {
               return true;
             }
             return this.hasChanged(model, field);
@@ -879,7 +893,9 @@ var MigrationGenerator = class {
           if (rawExistingFields.length) {
             this.updateFieldsRaw(model, rawExistingFields, up, down);
           }
-          const existingFields = model.fields.filter((field) => !field.generateAs && this.hasChanged(model, field));
+          const existingFields = model.fields.filter(
+            (field) => (!field.generateAs || field.generateAs.type === "expression") && this.hasChanged(model, field)
+          );
           this.updateFields(model, existingFields, up, down);
         }
         if (isUpdatableModel(model)) {
@@ -903,7 +919,7 @@ var MigrationGenerator = class {
                         writer.writeLine(`deleteRootType: row.deleteRootType,`);
                         writer.writeLine(`deleteRootId: row.deleteRootId,`);
                       }
-                      for (const { name: name2, kind } of model.fields.filter(isUpdatableField)) {
+                      for (const { name: name2, kind } of model.fields.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === "expression"))) {
                         const col = kind === "relation" ? `${name2}Id` : name2;
                         writer.writeLine(`${col}: row.${col},`);
                       }
@@ -917,8 +933,14 @@ 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" && !this.getColumn(revisionTable, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
+              ({ name: name2, ...field }) => field.kind !== "custom" && !(field.generateAs?.type === "expression") && !this.getColumn(revisionTable, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
             );
             this.createRevisionFields(model, missingRevisionFields, up, down);
             const revisionFieldsToRemove = model.fields.filter(
@@ -984,13 +1006,13 @@ var MigrationGenerator = class {
     this.migration("down", down.reverse());
     return writer.toString();
   }
-  renameFields(model, fields2, up, down) {
+  renameFields(tableName, fields2, up, down) {
     if (!fields2.length) {
       return;
     }
     up.push(() => {
       for (const field of fields2) {
-        this.alterTable(model.name, () => {
+        this.alterTable(tableName, () => {
           this.renameColumn(
             field.kind === "relation" ? `${field.oldName}Id` : get(field, "oldName"),
             field.kind === "relation" ? `${field.name}Id` : field.name
@@ -1000,7 +1022,7 @@ var MigrationGenerator = class {
     });
     down.push(() => {
       for (const field of fields2) {
-        this.alterTable(model.name, () => {
+        this.alterTable(tableName, () => {
           this.renameColumn(
             field.kind === "relation" ? `${field.name}Id` : field.name,
             field.kind === "relation" ? `${field.oldName}Id` : get(field, "oldName")
@@ -1009,7 +1031,7 @@ var MigrationGenerator = class {
       }
     });
     for (const field of fields2) {
-      summonByName(this.columns[model.name], field.kind === "relation" ? `${field.oldName}Id` : field.oldName).name = field.kind === "relation" ? `${field.name}Id` : field.name;
+      summonByName(this.columns[tableName], field.kind === "relation" ? `${field.oldName}Id` : field.oldName).name = field.kind === "relation" ? `${field.name}Id` : field.name;
     }
   }
   createFields(model, fields2, up, down) {
@@ -1021,6 +1043,9 @@ 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;
@@ -1073,7 +1098,7 @@ var MigrationGenerator = class {
       });
     });
     if (isUpdatableModel(model)) {
-      const updatableFields = fields2.filter(isUpdatableField);
+      const updatableFields = fields2.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === "expression"));
       if (!updatableFields.length) {
         return;
       }
@@ -1121,7 +1146,7 @@ var MigrationGenerator = class {
       });
     });
     if (isUpdatableModel(model)) {
-      const updatableFields = fields2.filter(isUpdatableField);
+      const updatableFields = fields2.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === "expression"));
       if (!updatableFields.length) {
         return;
       }
@@ -1159,7 +1184,7 @@ var MigrationGenerator = class {
           writer.writeLine(`table.uuid('deleteRootId');`);
         }
       }
-      for (const field of model.fields.filter(and(isUpdatableField, not(isInherited)))) {
+      for (const field of model.fields.filter(and(isUpdatableField, not(isInherited))).filter((f) => !(f.generateAs?.type === "expression"))) {
         this.column(field, { setUnique: false, setDefault: false });
       }
     });
@@ -1173,14 +1198,19 @@ var MigrationGenerator = class {
             this.column(field, { setUnique: false, setNonNull: false, setDefault: false });
           }
         });
-        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 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();
+        }
         const nonNullableMissingRevisionFields = missingRevisionFields.filter(({ nonNull: nonNull2 }) => nonNull2);
         if (nonNullableMissingRevisionFields.length) {
           this.alterTable(revisionTable, () => {
@@ -1236,7 +1266,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") {
@@ -1261,6 +1291,9 @@ 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:
@@ -1269,6 +1302,9 @@ 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.`);
           }
@@ -1288,10 +1324,10 @@ var MigrationGenerator = class {
             this.writer.write(`, ALTER COLUMN "${name2}" DROP NOT NULL`);
           }
         }
-        this.writer.write(`, ALTER COLUMN "${name2}" SET EXPRESSION AS (${field.generateAs})`);
+        this.writer.write(`, ALTER COLUMN "${name2}" SET EXPRESSION AS (${field.generateAs.expression})`);
       } else {
         this.writer.write(
-          `${alter ? "ALTER" : "ADD"} COLUMN "${name2}" ${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs}) STORED`
+          `${alter ? "ALTER" : "ADD"} COLUMN "${name2}" ${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs.expression}) STORED`
         );
       }
       return;
@@ -1315,6 +1351,9 @@ 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:
@@ -1323,6 +1362,9 @@ 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.`);
           }
@@ -1331,7 +1373,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}) STORED')`
+        `table.specificType('${name2}', '${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs.expression}) ${field.generateAs.type === "virtual" ? "VIRTUAL" : "STORED"}')`
       );
       if (alter) {
         this.writer.write(".alter()");
@@ -1429,14 +1471,17 @@ 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) {
+      if (col.generation_expression !== field.generateAs.expression) {
         throw new Error(
-          `Column ${col.name} has specific type ${col.generation_expression} but expected ${field.generateAs}`
+          `Column ${col.name} has specific type ${col.generation_expression} but expected ${field.generateAs.expression}`
         );
       }
     }
@@ -1478,6 +1523,182 @@ 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();
@@ -1490,21 +1711,258 @@ var getMigrationDate = () => {
   return `${year}${month}${day}${hours}${minutes}${seconds}`;
 };
 
-// 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/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/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");
 
@@ -2082,6 +2540,14 @@ 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",
@@ -2261,7 +2727,8 @@ var generateGraphqlClientTypes = async () => {
   });
 };
 
-// src/bin/gqm/parse-knexfile.ts
+// src/bin/gqm/parse-functions.ts
+var import_fs2 = require("fs");
 var import_ts_morph4 = require("ts-morph");
 
 // src/bin/gqm/static-eval.ts
@@ -2646,13 +3113,116 @@ var findDeclaration = (syntaxList, name2) => {
   }
 };
 
-// src/bin/gqm/parse-knexfile.ts
-var parseKnexfile = async () => {
+// 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({
+    manipulationSettings: {
+      indentationText: import_ts_morph5.IndentationText.TwoSpaces
+    }
+  });
   const knexfilePath = await getSetting("knexfilePath");
   ensureFileExists(knexfilePath, KNEXFILE);
   const sourceFile = project.addSourceFileAtPath(knexfilePath);
@@ -2662,11 +3232,11 @@ var parseKnexfile = async () => {
 };
 
 // src/bin/gqm/parse-models.ts
-var import_ts_morph5 = require("ts-morph");
+var import_ts_morph6 = require("ts-morph");
 var parseModels = async () => {
-  const project = new import_ts_morph5.Project({
+  const project = new import_ts_morph6.Project({
     manipulationSettings: {
-      indentationText: import_ts_morph5.IndentationText.TwoSpaces
+      indentationText: import_ts_morph6.IndentationText.TwoSpaces
     }
   });
   const modelsPath = await getSetting("modelsPath");
@@ -2679,11 +3249,11 @@ var parseModels = async () => {
 };
 
 // src/bin/gqm/permissions.ts
-var import_ts_morph6 = require("ts-morph");
+var import_ts_morph7 = require("ts-morph");
 var generatePermissionTypes = (models) => {
-  const project = new import_ts_morph6.Project({
+  const project = new import_ts_morph7.Project({
     manipulationSettings: {
-      indentationText: import_ts_morph6.IndentationText.TwoSpaces
+      indentationText: import_ts_morph7.IndentationText.TwoSpaces
     }
   });
   const sourceFile = project.createSourceFile("permissions.ts", "", {
@@ -2786,7 +3356,9 @@ import_commander.program.command("generate-migration [<name>] [<date>]").descrip
   const db = (0, import_knex.default)(knexfile);
   try {
     const models = await parseModels();
-    const migrations = await new MigrationGenerator(db, models).generate();
+    const functionsPath = await getSetting("functionsPath");
+    const parsedFunctions = parseFunctionsFile(functionsPath);
+    const migrations = await new MigrationGenerator(db, models, parsedFunctions).generate();
     writeToFile(`migrations/${date || getMigrationDate()}_${name2}.ts`, migrations);
   } finally {
     await db.destroy();
@@ -2797,7 +3369,9 @@ import_commander.program.command("check-needs-migration").description("Check if
   const db = (0, import_knex.default)(knexfile);
   try {
     const models = await parseModels();
-    const mg = new MigrationGenerator(db, models);
+    const functionsPath = await getSetting("functionsPath");
+    const parsedFunctions = parseFunctionsFile(functionsPath);
+    const mg = new MigrationGenerator(db, models, parsedFunctions);
     await mg.generate();
     if (mg.needsMigration) {
       console.error("Migration is needed.");
@@ -2807,8 +3381,31 @@ import_commander.program.command("check-needs-migration").description("Check if
     await db.destroy();
   }
 });
-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(" "));
+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.`);
   process.exit(1);
 });
 import_commander.program.parse(process.argv);