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

package/src/migrations/generate.ts

@@ -17,20 +17,10 @@ import {
   summonByName,
   typeToField,
 } from '../models/utils';
-import { getColumnName } from '../resolvers';
 import { Value } from '../values';
-import { ParsedFunction } from './types';
 
 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']({
@@ -42,14 +32,11 @@ export class MigrationGenerator {
   private uuidUsed?: boolean;
   private nowUsed?: boolean;
   public needsMigration = false;
-  private knex: Knex;
 
   constructor(
     knex: Knex,
     private models: Models,
-    private parsedFunctions?: ParsedFunction[],
   ) {
-    this.knex = knex;
     this.schema = SchemaInspector(knex);
   }
 
@@ -70,8 +57,6 @@ export class MigrationGenerator {
       down,
     );
 
-    await this.handleFunctions(up, down);
-
     for (const model of models.entities) {
       if (model.deleted) {
         up.push(() => {
@@ -142,9 +127,7 @@ export class MigrationGenerator {
                   foreignKey: 'id',
                 });
               }
-              for (const field of model.fields
-                .filter(not(isInherited))
-                .filter((f) => !(f.generateAs?.type === 'expression'))) {
+              for (const field of model.fields.filter(not(isInherited))) {
                 this.column(field);
               }
             });
@@ -155,8 +138,12 @@ export class MigrationGenerator {
           });
         } else {
           // Rename fields
-          const fieldsToRename = model.fields.filter(not(isInherited)).filter(({ oldName }) => oldName);
-          this.renameFields(model.name, fieldsToRename, up, down);
+          this.renameFields(
+            model,
+            model.fields.filter(not(isInherited)).filter(({ oldName }) => oldName),
+            up,
+            down,
+          );
 
           // Add missing fields
           this.createFields(
@@ -166,7 +153,6 @@ 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,
@@ -175,7 +161,7 @@ export class MigrationGenerator {
 
           // Update fields
           const rawExistingFields = model.fields.filter((field) => {
-            if (!field.generateAs || field.generateAs.type === 'expression') {
+            if (!field.generateAs) {
               return false;
             }
 
@@ -184,7 +170,7 @@ export class MigrationGenerator {
               return false;
             }
 
-            if (col.generation_expression !== field.generateAs.expression) {
+            if (col.generation_expression !== field.generateAs) {
               return true;
             }
 
@@ -194,9 +180,7 @@ export class MigrationGenerator {
             this.updateFieldsRaw(model, rawExistingFields, up, down);
           }
 
-          const existingFields = model.fields.filter(
-            (field) => (!field.generateAs || field.generateAs.type === 'expression') && this.hasChanged(model, field),
-          );
+          const existingFields = model.fields.filter((field) => !field.generateAs && this.hasChanged(model, field));
           this.updateFields(model, existingFields, up, down);
         }
 
@@ -228,9 +212,7 @@ export class MigrationGenerator {
                             writer.writeLine(`deleteRootId: row.deleteRootId,`);
                           }
 
-                          for (const { name, kind } of model.fields
-                            .filter(isUpdatableField)
-                            .filter((f) => !(f.generateAs?.type === 'expression'))) {
+                          for (const { name, kind } of model.fields.filter(isUpdatableField)) {
                             const col = kind === 'relation' ? `${name}Id` : name;
 
                             writer.writeLine(`${col}: row.${col},`);
@@ -249,23 +231,11 @@ 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),
               );
 
@@ -352,14 +322,14 @@ export class MigrationGenerator {
     return writer.toString();
   }
 
-  private renameFields(tableName: string, fields: EntityField[], up: Callbacks, down: Callbacks) {
+  private renameFields(model: EntityModel, fields: EntityField[], up: Callbacks, down: Callbacks) {
     if (!fields.length) {
       return;
     }
 
     up.push(() => {
       for (const field of fields) {
-        this.alterTable(tableName, () => {
+        this.alterTable(model.name, () => {
           this.renameColumn(
             field.kind === 'relation' ? `${field.oldName}Id` : get(field, 'oldName'),
             field.kind === 'relation' ? `${field.name}Id` : field.name,
@@ -370,7 +340,7 @@ export class MigrationGenerator {
 
     down.push(() => {
       for (const field of fields) {
-        this.alterTable(tableName, () => {
+        this.alterTable(model.name, () => {
           this.renameColumn(
             field.kind === 'relation' ? `${field.name}Id` : field.name,
             field.kind === 'relation' ? `${field.oldName}Id` : get(field, 'oldName'),
@@ -380,7 +350,7 @@ export class MigrationGenerator {
     });
 
     for (const field of fields) {
-      summonByName(this.columns[tableName], field.kind === 'relation' ? `${field.oldName!}Id` : field.oldName!).name =
+      summonByName(this.columns[model.name], field.kind === 'relation' ? `${field.oldName!}Id` : field.oldName!).name =
         field.kind === 'relation' ? `${field.name}Id` : field.name;
     }
   }
@@ -395,10 +365,6 @@ 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) {
@@ -464,7 +430,7 @@ export class MigrationGenerator {
     });
 
     if (isUpdatableModel(model)) {
-      const updatableFields = fields.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === 'expression'));
+      const updatableFields = fields.filter(isUpdatableField);
       if (!updatableFields.length) {
         return;
       }
@@ -518,7 +484,7 @@ export class MigrationGenerator {
     });
 
     if (isUpdatableModel(model)) {
-      const updatableFields = fields.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === 'expression'));
+      const updatableFields = fields.filter(isUpdatableField);
       if (!updatableFields.length) {
         return;
       }
@@ -562,9 +528,7 @@ export class MigrationGenerator {
         }
       }
 
-      for (const field of model.fields
-        .filter(and(isUpdatableField, not(isInherited)))
-        .filter((f) => !(f.generateAs?.type === 'expression'))) {
+      for (const field of model.fields.filter(and(isUpdatableField, not(isInherited)))) {
         this.column(field, { setUnique: false, setDefault: false });
       }
     });
@@ -582,31 +546,23 @@ export class MigrationGenerator {
         });
 
         // Insert data for missing revisions columns
-        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();
-        }
+        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 nonNullableMissingRevisionFields = missingRevisionFields.filter(({ nonNull }) => nonNull);
         if (nonNullableMissingRevisionFields.length) {
@@ -690,7 +646,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) {
@@ -725,10 +681,6 @@ 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:
@@ -737,9 +689,6 @@ 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.`);
           }
@@ -759,10 +708,10 @@ export class MigrationGenerator {
             this.writer.write(`, ALTER COLUMN "${name}" DROP NOT NULL`);
           }
         }
-        this.writer.write(`, ALTER COLUMN "${name}" SET EXPRESSION AS (${field.generateAs.expression})`);
+        this.writer.write(`, ALTER COLUMN "${name}" SET EXPRESSION AS (${field.generateAs})`);
       } else {
         this.writer.write(
-          `${alter ? 'ALTER' : 'ADD'} COLUMN "${name}" ${type}${nonNull() ? ' not null' : ''} GENERATED ALWAYS AS (${field.generateAs.expression}) STORED`,
+          `${alter ? 'ALTER' : 'ADD'} COLUMN "${name}" ${type}${nonNull() ? ' not null' : ''} GENERATED ALWAYS AS (${field.generateAs}) STORED`,
         );
       }
 
@@ -795,10 +744,6 @@ 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:
@@ -807,9 +752,6 @@ 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.`);
           }
@@ -818,7 +760,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.expression}) ${field.generateAs.type === 'virtual' ? 'VIRTUAL' : 'STORED'}')`,
+        `table.specificType('${name}', '${type}${nonNull() ? ' not null' : ''} GENERATED ALWAYS AS (${field.generateAs}) STORED')`,
       );
       if (alter) {
         this.writer.write('.alter()');
@@ -923,19 +865,15 @@ 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.expression) {
+      if (col.generation_expression !== field.generateAs) {
         throw new Error(
-          `Column ${col.name} has specific type ${col.generation_expression} but expected ${field.generateAs.expression}`,
+          `Column ${col.name} has specific type ${col.generation_expression} but expected ${field.generateAs}`,
         );
       }
     }
@@ -980,237 +918,6 @@ 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.parsedFunctions || this.parsedFunctions.length === 0) {
-      return;
-    }
-
-    const definedFunctions = this.parsedFunctions;
-
-    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,5 +1,3 @@
 // created from 'create-ts-index'
 
 export * from './generate';
-export * from './generate-functions';
-export * from './update-functions';

package/src/models/model-definitions.ts

@@ -90,10 +90,7 @@ export type EntityFieldDefinition = FieldDefinitionBase &
     indent?: boolean;
     // If true the field is hidden in the admin interface
     hidden?: boolean;
-    generateAs?: {
-      expression: string;
-      type: 'virtual' | 'stored' | 'expression';
-    };
+    generateAs?: string;
 
     // Temporary fields for the generation of migrations
     deleted?: true;