@smartive/graphql-magic 23.3.0 → 23.4.0-next.4

package/src/migrations/generate-functions.ts

@@ -0,0 +1,72 @@
+import { Knex } from 'knex';
+
+export const generateFunctionsFromDatabase = async (knex: Knex): Promise<string> => {
+  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: string[] = [];
+
+  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 '-- PostgreSQL functions\n-- No functions found in database\n';
+  }
+
+  return functions.join('\n\n') + '\n';
+};

package/src/migrations/generate.ts

@@ -17,10 +17,20 @@ import {
   summonByName,
   typeToField,
 } from '../models/utils';
+import { getColumnName } from '../resolvers';
 import { Value } from '../values';
+import { ParsedFunction, parseFunctionsFile } from './parse-functions';
 
 type Callbacks = (() => void)[];
 
+type DatabaseFunction = {
+  name: string;
+  signature: string;
+  body: string;
+  isAggregate: boolean;
+  definition?: string;
+};
+
 export class MigrationGenerator {
   // eslint-disable-next-line @typescript-eslint/dot-notation
   private writer: CodeBlockWriter = new CodeBlockWriter['default']({
@@ -32,11 +42,14 @@ export class MigrationGenerator {
   private uuidUsed?: boolean;
   private nowUsed?: boolean;
   public needsMigration = false;
+  private knex: Knex;
 
   constructor(
     knex: Knex,
     private models: Models,
+    private functionsFilePath?: string,
   ) {
+    this.knex = knex;
     this.schema = SchemaInspector(knex);
   }
 
@@ -57,6 +70,8 @@ export class MigrationGenerator {
       down,
     );
 
+    await this.handleFunctions(up, down);
+
     for (const model of models.entities) {
       if (model.deleted) {
         up.push(() => {
@@ -127,7 +142,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);
               }
             });
@@ -138,12 +155,8 @@ 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(
@@ -153,6 +166,7 @@ export class MigrationGenerator {
               .filter(
                 ({ name, ...field }) =>
                   field.kind !== 'custom' &&
+                  !(field.generateAs?.type === 'expression') &&
                   !this.getColumn(model.name, field.kind === 'relation' ? field.foreignKey || `${name}Id` : name),
               ),
             up,
@@ -161,7 +175,7 @@ export class MigrationGenerator {
 
           // Update fields
           const rawExistingFields = model.fields.filter((field) => {
-            if (!field.generateAs) {
+            if (!field.generateAs || field.generateAs.type === 'expression') {
               return false;
             }
 
@@ -170,7 +184,7 @@ export class MigrationGenerator {
               return false;
             }
 
-            if (col.generation_expression !== field.generateAs) {
+            if (col.generation_expression !== field.generateAs.expression) {
               return true;
             }
 
@@ -180,7 +194,9 @@ export class MigrationGenerator {
             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);
         }
 
@@ -212,7 +228,9 @@ export class MigrationGenerator {
                             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},`);
@@ -231,11 +249,23 @@ 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),
               );
 
@@ -322,14 +352,14 @@ export class MigrationGenerator {
     return writer.toString();
   }
 
-  private renameFields(model: EntityModel, fields: EntityField[], up: Callbacks, down: Callbacks) {
+  private renameFields(tableName: string, fields: EntityField[], up: Callbacks, down: Callbacks) {
     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,
@@ -340,7 +370,7 @@ export class MigrationGenerator {
 
     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'),
@@ -350,7 +380,7 @@ export class MigrationGenerator {
     });
 
     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;
     }
   }
@@ -365,6 +395,10 @@ export class MigrationGenerator {
       const updates: Callbacks = [];
       const postAlter: Callbacks = [];
       for (const field of fields) {
+        if (field.generateAs?.type === 'expression') {
+          continue;
+        }
+
         alter.push(() => this.column(field, { setNonNull: field.defaultValue !== undefined }));
 
         if (field.generateAs) {
@@ -430,7 +464,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;
       }
@@ -484,7 +518,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;
       }
@@ -528,7 +562,9 @@ export class MigrationGenerator {
         }
       }
 
-      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 });
       }
     });
@@ -546,23 +582,31 @@ 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) {
@@ -646,7 +690,7 @@ export class MigrationGenerator {
   }
 
   private renameColumn(from: string, to: string) {
-    this.writer.writeLine(`table.renameColumn('${from}', '${to}')`);
+    this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
   }
 
   private value(value: Value) {
@@ -681,6 +725,10 @@ 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:
@@ -689,6 +737,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.`);
           }
@@ -708,10 +759,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`,
+          `${alter ? 'ALTER' : 'ADD'} COLUMN "${name}" ${type}${nonNull() ? ' not null' : ''} GENERATED ALWAYS AS (${field.generateAs.expression}) STORED`,
         );
       }
 
@@ -744,6 +795,10 @@ 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:
@@ -752,6 +807,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.`);
           }
@@ -760,7 +818,7 @@ export class MigrationGenerator {
           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')`,
+        `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()');
@@ -865,15 +923,19 @@ export class MigrationGenerator {
   }
 
   private hasChanged(model: EntityModel, field: EntityField) {
+    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}`,
         );
       }
     }
@@ -918,6 +980,241 @@ export class MigrationGenerator {
 
     return false;
   }
+
+  private normalizeFunctionBody(body: string): string {
+    return body
+      .replace(/\s+/g, ' ')
+      .replace(/\s*\(\s*/g, '(')
+      .replace(/\s*\)\s*/g, ')')
+      .replace(/\s*,\s*/g, ',')
+      .trim();
+  }
+
+  private normalizeAggregateDefinition(definition: string): string {
+    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;
+  }
+
+  private extractFunctionBody(definition: string): string {
+    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;
+  }
+
+  private async getDatabaseFunctions(): Promise<DatabaseFunction[]> {
+    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: DatabaseFunction[] = [];
+
+    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: string;
+        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;
+  }
+
+  private async handleFunctions(up: Callbacks, down: Callbacks) {
+    if (!this.functionsFilePath) {
+      return;
+    }
+
+    const definedFunctions = parseFunctionsFile(this.functionsFilePath);
+
+    if (definedFunctions.length === 0) {
+      return;
+    }
+
+    const dbFunctions = await this.getDatabaseFunctions();
+    const dbFunctionsBySignature = new Map<string, DatabaseFunction>();
+    for (const func of dbFunctions) {
+      dbFunctionsBySignature.set(func.signature, func);
+    }
+
+    const definedFunctionsBySignature = new Map<string, ParsedFunction>();
+    for (const func of definedFunctions) {
+      definedFunctionsBySignature.set(func.signature, func);
+    }
+
+    const functionsToRestore: { func: DatabaseFunction; definition: string }[] = [];
+
+    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 = () => {

package/src/migrations/index.ts

@@ -1,3 +1,5 @@
 // created from 'create-ts-index'
 
 export * from './generate';
+export * from './generate-functions';
+export * from './update-functions';