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

package/dist/esm/migrations/generate-functions.d.ts

@@ -0,0 +1,2 @@
+import { Knex } from 'knex';
+export declare const generateFunctionsFromDatabase: (knex: Knex) => Promise<string>;

package/dist/esm/migrations/generate-functions.js

@@ -0,0 +1,60 @@
+export const generateFunctionsFromDatabase = async (knex) => {
+    const regularFunctions = await knex.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 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
+    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 name = 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 (!name || !transFunc || !stateType) {
+            continue;
+        }
+        let aggregateDef = `CREATE AGGREGATE ${name}(${argumentsStr}) (\n`;
+        aggregateDef += `  SFUNC = ${transFunc},\n`;
+        aggregateDef += `  STYPE = ${stateType}`;
+        if (finalFunc) {
+            aggregateDef += `,\n  FINALFUNC = ${finalFunc}`;
+        }
+        if (initVal !== null && initVal !== undefined) {
+            const initValStr = typeof initVal === 'string' ? `'${initVal}'` : String(initVal);
+            aggregateDef += `,\n  INITCOND = ${initValStr}`;
+        }
+        aggregateDef += '\n);';
+        functions.push(aggregateDef);
+    }
+    if (functions.length === 0) {
+        return `export const functions: string[] = [];\n`;
+    }
+    const functionsArrayString = functions.map((func) => `  ${JSON.stringify(func)}`).join(',\n');
+    return `export const functions: string[] = [\n${functionsArrayString},\n];\n`;
+};
+//# sourceMappingURL=generate-functions.js.map

package/dist/esm/migrations/generate-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-functions.js","sourceRoot":"","sources":["../../../src/migrations/generate-functions.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,6BAA6B,GAAG,KAAK,EAAE,IAAU,EAAmB,EAAE;IACjF,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC;;;;;;;;GAQvC,CAAC,CAAC;IAEH,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC;;;;;;;;;;;;;GAazC,CAAC,CAAC;IAEH,MAAM,SAAS,GAAa,EAAE,CAAC;IAE/B,KAAK,MAAM,GAAG,IAAI,gBAAgB,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;QAC9C,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC;YACnB,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAED,KAAK,MAAM,GAAG,IAAI,kBAAkB,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;QAChD,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC;QAC5B,MAAM,YAAY,GAAG,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC;QACzC,MAAM,SAAS,GAAG,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC;QACvC,MAAM,SAAS,GAAG,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC;QACvC,MAAM,OAAO,GAAG,GAAG,CAAC,QAAQ,CAAC;QAC7B,MAAM,SAAS,GAAG,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC;QAEvC,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,EAAE,CAAC;YACtC,SAAS;QACX,CAAC;QAED,IAAI,YAAY,GAAG,oBAAoB,IAAI,IAAI,YAAY,OAAO,CAAC;QACnE,YAAY,IAAI,aAAa,SAAS,KAAK,CAAC;QAC5C,YAAY,IAAI,aAAa,SAAS,EAAE,CAAC;QAEzC,IAAI,SAAS,EAAE,CAAC;YACd,YAAY,IAAI,oBAAoB,SAAS,EAAE,CAAC;QAClD,CAAC;QAED,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC9C,MAAM,UAAU,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAClF,YAAY,IAAI,mBAAmB,UAAU,EAAE,CAAC;QAClD,CAAC;QAED,YAAY,IAAI,MAAM,CAAC;QAEvB,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC/B,CAAC;IAED,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,0CAA0C,CAAC;IACpD,CAAC;IAED,MAAM,oBAAoB,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAE9F,OAAO,yCAAyC,oBAAoB,SAAS,CAAC;AAChF,CAAC,CAAC"}

package/dist/esm/migrations/generate.d.ts

@@ -1,14 +1,17 @@
 import { Knex } from 'knex';
 import { Models } from '../models/models';
+import { ParsedFunction } from './types';
 export declare class MigrationGenerator {
     private models;
+    private parsedFunctions?;
     private writer;
     private schema;
     private columns;
     private uuidUsed?;
     private nowUsed?;
     needsMigration: boolean;
-    constructor(knex: Knex, models: Models);
+    private knex;
+    constructor(knex: Knex, models: Models, parsedFunctions?: ParsedFunction[] | undefined);
     generate(): Promise<string>;
     private renameFields;
     private createFields;
@@ -30,5 +33,10 @@ export declare class MigrationGenerator {
     private column;
     private getColumn;
     private hasChanged;
+    private normalizeFunctionBody;
+    private normalizeAggregateDefinition;
+    private extractFunctionBody;
+    private getDatabaseFunctions;
+    private handleFunctions;
 }
 export declare const getMigrationDate: () => string;

package/dist/esm/migrations/generate.js

@@ -2,8 +2,10 @@ import CodeBlockWriter from 'code-block-writer';
 import { SchemaInspector } from 'knex-schema-inspector';
 import lowerFirst from 'lodash/lowerFirst';
 import { and, get, isCreatableModel, isInherited, isUpdatableField, isUpdatableModel, modelNeedsTable, not, summonByName, typeToField, } from '../models/utils';
+import { getColumnName } from '../resolvers';
 export class MigrationGenerator {
     models;
+    parsedFunctions;
     // eslint-disable-next-line @typescript-eslint/dot-notation
     writer = new CodeBlockWriter['default']({
         useSingleQuote: true,
@@ -14,8 +16,11 @@ export class MigrationGenerator {
     uuidUsed;
     nowUsed;
     needsMigration = false;
-    constructor(knex, models) {
+    knex;
+    constructor(knex, models, parsedFunctions) {
         this.models = models;
+        this.parsedFunctions = parsedFunctions;
+        this.knex = knex;
         this.schema = SchemaInspector(knex);
     }
     async generate() {
@@ -28,6 +33,7 @@ export class MigrationGenerator {
         const up = [];
         const down = [];
         this.createEnums(this.models.enums.filter((enm) => !enums.includes(lowerFirst(enm.name))), up, down);
+        await this.handleFunctions(up, down);
         for (const model of models.entities) {
             if (model.deleted) {
                 up.push(() => {
@@ -92,7 +98,9 @@ export class MigrationGenerator {
                                     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);
                             }
                         });
@@ -103,22 +111,24 @@ export class MigrationGenerator {
                 }
                 else {
                     // Rename fields
-                    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);
                     // Add missing fields
                     this.createFields(model, model.fields
                         .filter(not(isInherited))
                         .filter(({ name, ...field }) => field.kind !== 'custom' &&
+                        !(field.generateAs?.type === 'expression') &&
                         !this.getColumn(model.name, field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)), up, down);
                     // Update fields
                     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);
@@ -126,7 +136,7 @@ export class MigrationGenerator {
                     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)) {
@@ -154,7 +164,9 @@ export class MigrationGenerator {
                                                 writer.writeLine(`deleteRootType: row.deleteRootType,`);
                                                 writer.writeLine(`deleteRootId: row.deleteRootId,`);
                                             }
-                                            for (const { name, kind } of model.fields.filter(isUpdatableField)) {
+                                            for (const { name, kind } of model.fields
+                                                .filter(isUpdatableField)
+                                                .filter((f) => !(f.generateAs?.type === 'expression'))) {
                                                 const col = kind === 'relation' ? `${name}Id` : name;
                                                 writer.writeLine(`${col}: row.${col},`);
                                             }
@@ -172,9 +184,14 @@ export class MigrationGenerator {
                     }
                     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, ...field }) => field.kind !== 'custom' &&
+                            !(field.generateAs?.type === 'expression') &&
                             !this.getColumn(revisionTable, field.kind === 'relation' ? field.foreignKey || `${name}Id` : name));
                         this.createRevisionFields(model, missingRevisionFields, up, down);
                         const revisionFieldsToRemove = model.fields.filter(({ name, updatable, generated, ...field }) => !generated &&
@@ -233,26 +250,26 @@ export class MigrationGenerator {
         this.migration('down', down.reverse());
         return writer.toString();
     }
-    renameFields(model, fields, up, down) {
+    renameFields(tableName, fields, up, down) {
         if (!fields.length) {
             return;
         }
         up.push(() => {
             for (const field of fields) {
-                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);
                 });
             }
         });
         down.push(() => {
             for (const field of fields) {
-                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'));
                 });
             }
         });
         for (const field of fields) {
-            summonByName(this.columns[model.name], field.kind === 'relation' ? `${field.oldName}Id` : field.oldName).name =
+            summonByName(this.columns[tableName], field.kind === 'relation' ? `${field.oldName}Id` : field.oldName).name =
                 field.kind === 'relation' ? `${field.name}Id` : field.name;
         }
     }
@@ -265,6 +282,9 @@ export class MigrationGenerator {
             const updates = [];
             const postAlter = [];
             for (const field of fields) {
+                if (field.generateAs?.type === 'expression') {
+                    continue;
+                }
                 alter.push(() => this.column(field, { setNonNull: field.defaultValue !== undefined }));
                 if (field.generateAs) {
                     continue;
@@ -323,7 +343,7 @@ export class MigrationGenerator {
             });
         });
         if (isUpdatableModel(model)) {
-            const updatableFields = fields.filter(isUpdatableField);
+            const updatableFields = fields.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === 'expression'));
             if (!updatableFields.length) {
                 return;
             }
@@ -362,7 +382,7 @@ export class MigrationGenerator {
             });
         });
         if (isUpdatableModel(model)) {
-            const updatableFields = fields.filter(isUpdatableField);
+            const updatableFields = fields.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === 'expression'));
             if (!updatableFields.length) {
                 return;
             }
@@ -397,7 +417,9 @@ export class MigrationGenerator {
                     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 });
             }
         });
@@ -413,19 +435,24 @@ export class MigrationGenerator {
                     }
                 });
                 // Insert data for missing revisions columns
-                this.writer
-                    .write(`await knex('${model.name}Revision').update(`)
-                    .inlineBlock(() => {
-                    for (const { name, kind: type } of missingRevisionFields) {
-                        const col = type === 'relation' ? `${name}Id` : name;
-                        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 !== undefined ||
+                    field.nonNull);
+                if (revisionFieldsWithDataToCopy.length) {
+                    this.writer
+                        .write(`await knex('${model.name}Revision').update(`)
+                        .inlineBlock(() => {
+                        for (const { name, kind: type } of revisionFieldsWithDataToCopy) {
+                            const col = type === 'relation' ? `${name}Id` : name;
+                            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 }) => nonNull);
                 if (nonNullableMissingRevisionFields.length) {
                     this.alterTable(revisionTable, () => {
@@ -494,7 +521,7 @@ export class MigrationGenerator {
         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(value) {
         if (typeof value === 'string') {
@@ -519,6 +546,9 @@ export class MigrationGenerator {
         };
         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 undefined:
@@ -527,6 +557,9 @@ export class MigrationGenerator {
                         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.`);
                     }
@@ -547,10 +580,10 @@ export class MigrationGenerator {
                         this.writer.write(`, ALTER COLUMN "${name}" DROP NOT NULL`);
                     }
                 }
-                this.writer.write(`, ALTER COLUMN "${name}" SET EXPRESSION AS (${field.generateAs})`);
+                this.writer.write(`, ALTER COLUMN "${name}" SET EXPRESSION AS (${field.generateAs.expression})`);
             }
             else {
-                this.writer.write(`${alter ? 'ALTER' : 'ADD'} COLUMN "${name}" ${type}${nonNull() ? ' not null' : ''} GENERATED ALWAYS AS (${field.generateAs}) STORED`);
+                this.writer.write(`${alter ? 'ALTER' : 'ADD'} COLUMN "${name}" ${type}${nonNull() ? ' not null' : ''} GENERATED ALWAYS AS (${field.generateAs.expression}) STORED`);
             }
             return;
         }
@@ -573,6 +606,9 @@ export class MigrationGenerator {
         };
         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 undefined:
@@ -581,6 +617,9 @@ export class MigrationGenerator {
                         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.`);
                     }
@@ -588,7 +627,7 @@ export class MigrationGenerator {
                 default:
                     throw new Error(`Generated columns of kind ${kind} are not supported yet.`);
             }
-            this.writer.write(`table.specificType('${name}', '${type}${nonNull() ? ' not null' : ''} GENERATED ALWAYS AS (${field.generateAs}) STORED')`);
+            this.writer.write(`table.specificType('${name}', '${type}${nonNull() ? ' not null' : ''} GENERATED ALWAYS AS (${field.generateAs.expression}) ${field.generateAs.type === 'virtual' ? 'VIRTUAL' : 'STORED'}')`);
             if (alter) {
                 this.writer.write('.alter()');
             }
@@ -690,13 +729,16 @@ export class MigrationGenerator {
         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) {
-                throw new Error(`Column ${col.name} has specific type ${col.generation_expression} but expected ${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.expression}`);
             }
         }
         if ((!field.nonNull && !col.is_nullable) || (field.nonNull && col.is_nullable)) {
@@ -738,6 +780,200 @@ export class MigrationGenerator {
         }
         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 name = row.name || '';
+            const argumentsStr = row.arguments || '';
+            if (!definition) {
+                continue;
+            }
+            const signature = `${name}(${argumentsStr})`;
+            const body = this.normalizeFunctionBody(this.extractFunctionBody(definition));
+            result.push({
+                name,
+                signature,
+                body,
+                isAggregate: false,
+                definition,
+            });
+        }
+        for (const row of aggregateFunctions.rows || []) {
+            const name = 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 = `${name}(${argumentsStr})`;
+            let aggregateDef = `CREATE AGGREGATE ${name}(${argumentsStr}) (`;
+            aggregateDef += `SFUNC = ${transFunc}, STYPE = ${stateType}`;
+            if (finalFunc) {
+                aggregateDef += `, FINALFUNC = ${finalFunc}`;
+            }
+            if (initVal !== null && initVal !== undefined) {
+                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,
+                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 = new Map();
+        for (const func of dbFunctions) {
+            dbFunctionsBySignature.set(func.signature, func);
+        }
+        const definedFunctionsBySignature = 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 args = argsMatch ? argsMatch[3].trim() : '';
+                        const dropType = isAggregate ? 'AGGREGATE' : 'FUNCTION';
+                        this.writer
+                            .writeLine(`await knex.raw(\`DROP ${dropType} IF EXISTS ${functionName}${args ? `(${args})` : ''}\`);`)
+                            .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 args = argsMatch ? argsMatch[1] : '';
+                        const dropType = dbFunc.isAggregate ? 'AGGREGATE' : 'FUNCTION';
+                        this.writer
+                            .writeLine(`await knex.raw(\`DROP ${dropType} IF EXISTS ${dbFunc.name}${args ? `(${args})` : ''}\`);`)
+                            .blankLine();
+                    });
+                }
+            }
+        }
+        for (const { definition } of functionsToRestore) {
+            up.push(() => {
+                this.writer.writeLine(`await knex.raw(\`${definition.replace(/`/g, '\\`')}\`);`).blankLine();
+            });
+        }
+    }
 }
 export const getMigrationDate = () => {
     const date = new Date();