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

package/CHANGELOG.md

@@ -1,20 +1,5 @@
-## [23.5.0-next.1](https://github.com/smartive/graphql-magic/compare/v23.4.1...v23.5.0-next.1) (2026-02-09)
+## [23.5.0](https://github.com/smartive/graphql-magic/compare/v23.4.1...v23.5.0) (2026-02-09)
 
 ### Features
 
-* functions.sql and expression fiedls ([65d7079](https://github.com/smartive/graphql-magic/commit/65d7079b54da3a11300cb714a7ca70032e591204))
-* Use functions.ts instead of functions.sql ([58e0653](https://github.com/smartive/graphql-magic/commit/58e065347b2f3f1c80691911b5191af38586c1e2))
-
-### Bug Fixes
-
-* Functions code order ([cf7f7a4](https://github.com/smartive/graphql-magic/commit/cf7f7a4421e8297af866c3ecc04b5e672862e6ab))
-* Generated expression handling ([e325eb2](https://github.com/smartive/graphql-magic/commit/e325eb232b7bbbbe7d65f9fae5221f4a764a8600))
-* improve handling of missing revision fields in migration updates ([4296662](https://github.com/smartive/graphql-magic/commit/429666247224ef782280fd6144cb749468b934cd))
-* Index ([42d109f](https://github.com/smartive/graphql-magic/commit/42d109fc6dbbf8fc7937f076403a69885779d8f6))
-* Linting ([2e997e4](https://github.com/smartive/graphql-magic/commit/2e997e464371a9d8cf05ceb67a6cd29a9452f615))
-* Omit more stuff ([df2ae04](https://github.com/smartive/graphql-magic/commit/df2ae044557166e876b7646d6ebe67a78df2722e))
-* Permissions ([c198115](https://github.com/smartive/graphql-magic/commit/c19811552ac3de05d4c1069116620067ec0a5540))
-* Temporarily disable tags ([52962c1](https://github.com/smartive/graphql-magic/commit/52962c1a792c1ae010ae542c23d50dd4f8486dde))
-* Trigger release ([2cd67b9](https://github.com/smartive/graphql-magic/commit/2cd67b91d33d101793c04eb87ad9c226bc0fdd0f))
-* Trigger release ([d5ac376](https://github.com/smartive/graphql-magic/commit/d5ac376533460921a638c71f4c9a69c83a057897))
-* Update functions ([3717f8a](https://github.com/smartive/graphql-magic/commit/3717f8aba9d908fbde8d2f49e7c21f87fe6a8d12))
+* Functions migration generator ([0525bb5](https://github.com/smartive/graphql-magic/commit/0525bb5d182bdd258fd6408be32bfb9ce5146faa))

package/dist/bin/gqm.cjs

@@ -763,6 +763,204 @@ var getColumnName = (field) => field.kind === "relation" ? field.foreignKey || `
 var import_cloneDeep2 = __toESM(require("lodash/cloneDeep"), 1);
 var import_flatMap = __toESM(require("lodash/flatMap"), 1);
 
+// 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 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;
+};
+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) {
+      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: normalizeAggregateDefinition(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/migrations/generate.ts
 var MigrationGenerator = class {
   constructor(knex2, models, parsedFunctions) {
@@ -1327,7 +1525,7 @@ var MigrationGenerator = class {
         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.expression}) STORED`
+          `ADD COLUMN "${name2}" ${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs.expression}) STORED`
         );
       }
       return;
@@ -1523,118 +1721,12 @@ 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 dbFunctions = await getDatabaseFunctions(this.knex);
     const dbFunctionsBySignature = /* @__PURE__ */ new Map();
     for (const func of dbFunctions) {
       dbFunctionsBySignature.set(func.signature, func);
@@ -1664,8 +1756,8 @@ var MigrationGenerator = class {
           }
         });
       } 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);
+        const dbBody = dbFunc.isAggregate ? normalizeAggregateDefinition(dbFunc.body) : normalizeFunctionBody(dbFunc.body);
+        const definedBody = definedFunc.isAggregate ? normalizeAggregateDefinition(definedFunc.body) : normalizeFunctionBody(definedFunc.body);
         if (dbBody !== definedBody) {
           const oldDefinition = dbFunc.definition || dbFunc.body;
           up.push(() => {
@@ -1780,186 +1872,6 @@ ${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"];
 
@@ -3120,7 +3032,7 @@ var normalizeWhitespace2 = (str) => {
 var normalizeFunctionBody2 = (body) => {
   return normalizeWhitespace2(body);
 };
-var normalizeAggregateDefinition = (definition) => {
+var normalizeAggregateDefinition2 = (definition) => {
   let normalized = normalizeWhitespace2(definition);
   const initCondMatch = normalized.match(/INITCOND\s*=\s*([^,)]+)/i);
   if (initCondMatch) {
@@ -3204,7 +3116,7 @@ var parseFunctionsFile = (filePath) => {
       parsedFunctions.push({
         name: name2,
         signature,
-        body: isAggregate ? normalizeAggregateDefinition(body) : normalizeFunctionBody2(body),
+        body: isAggregate ? normalizeAggregateDefinition2(body) : normalizeFunctionBody2(body),
         fullDefinition: trimmedDefinition,
         isAggregate
       });