@smartive/graphql-magic 22.3.0 → 22.5.0

package/src/migrations/generate.ts

@@ -160,35 +160,27 @@ export class MigrationGenerator {
           );
 
           // Update fields
-          const existingFields = model.fields.filter((field) => {
+          const rawExistingFields = model.fields.filter((field) => {
+            if (!field.generateAs) {
+              return false;
+            }
+
             const col = this.getColumn(model.name, field.kind === 'relation' ? `${field.name}Id` : field.name);
             if (!col) {
               return false;
             }
 
-            if ((!field.nonNull && !col.is_nullable) || (field.nonNull && col.is_nullable)) {
+            if (col.generation_expression !== field.generateAs) {
               return true;
             }
 
-            if (!field.kind || field.kind === 'primitive') {
-              if (field.type === 'Int') {
-                if (col.data_type !== 'integer') {
-                  return true;
-                }
-              }
-              if (field.type === 'Float') {
-                if (field.double) {
-                  if (col.data_type !== 'double precision') {
-                    return true;
-                  }
-                } else if (col.data_type !== 'numeric') {
-                  return true;
-                }
-              }
-            }
-
-            return false;
+            return this.hasChanged(model, field);
           });
+          if (rawExistingFields.length) {
+            this.updateFieldsRaw(model, rawExistingFields, up, down);
+          }
+
+          const existingFields = model.fields.filter((field) => !field.generateAs && this.hasChanged(model, field));
           this.updateFields(model, existingFields, up, down);
         }
 
@@ -375,6 +367,10 @@ export class MigrationGenerator {
       for (const field of fields) {
         alter.push(() => this.column(field, { setNonNull: field.defaultValue !== undefined }));
 
+        if (field.generateAs) {
+          continue;
+        }
+
         // If the field is not nullable but has no default, write placeholder code
         if (field.nonNull && field.defaultValue === undefined) {
           updates.push(() => this.writer.write(`${field.name}: 'TODO',`).newLine());
@@ -405,13 +401,63 @@ export class MigrationGenerator {
 
     down.push(() => {
       this.alterTable(model.name, () => {
-        for (const { kind, name } of fields) {
+        for (const { kind, name } of fields.toReversed()) {
           this.dropColumn(kind === 'relation' ? `${name}Id` : name);
         }
       });
     });
   }
 
+  private updateFieldsRaw(model: EntityModel, fields: EntityField[], up: Callbacks, down: Callbacks) {
+    if (!fields.length) {
+      return;
+    }
+
+    up.push(() => {
+      this.alterTableRaw(model.name, () => {
+        for (const [index, field] of fields.entries()) {
+          this.columnRaw(field, { alter: true }, index);
+        }
+      });
+    });
+
+    down.push(() => {
+      this.alterTableRaw(model.name, () => {
+        for (const [index, field] of fields.entries()) {
+          this.columnRaw(field, { alter: true }, index);
+        }
+      });
+    });
+
+    if (isUpdatableModel(model)) {
+      const updatableFields = fields.filter(isUpdatableField);
+      if (!updatableFields.length) {
+        return;
+      }
+
+      up.push(() => {
+        this.alterTable(`${model.name}Revision`, () => {
+          for (const [index, field] of updatableFields.entries()) {
+            this.columnRaw(field, { alter: true }, index);
+          }
+        });
+      });
+
+      down.push(() => {
+        this.alterTable(`${model.name}Revision`, () => {
+          for (const [index, field] of updatableFields.entries()) {
+            this.columnRaw(
+              field,
+              { alter: true },
+              index,
+              summonByName(this.columns[model.name], field.kind === 'relation' ? `${field.name}Id` : field.name),
+            );
+          }
+        });
+      });
+    }
+  }
+
   private updateFields(model: EntityModel, fields: EntityField[], up: Callbacks, down: Callbacks) {
     if (!fields.length) {
       return;
@@ -572,6 +618,12 @@ export class MigrationGenerator {
       .blankLine();
   }
 
+  private alterTableRaw(table: string, block: () => void) {
+    this.writer.write(`await knex.raw('ALTER TABLE "${table}"`);
+    block();
+    this.writer.write(`');`).newLine().blankLine();
+  }
+
   private alterTable(table: string, block: () => void) {
     return this.writer
       .write(`await knex.schema.alterTable('${table}', (table) => `)
@@ -605,29 +657,125 @@ export class MigrationGenerator {
     return value;
   }
 
+  private columnRaw(
+    { name, ...field }: EntityField,
+    { setNonNull = true, alter = false } = {},
+    index: number,
+    toColumn?: Column,
+  ) {
+    const nonNull = () => {
+      if (setNonNull) {
+        if (toColumn) {
+          if (toColumn.is_nullable) {
+            return false;
+          }
+
+          return true;
+        }
+        if (field.nonNull) {
+          return true;
+        }
+
+        return false;
+      }
+    };
+    const kind = field.kind;
+    if (field.generateAs) {
+      let type = '';
+      switch (kind) {
+        case undefined:
+        case 'primitive':
+          switch (field.type) {
+            case 'Float':
+              type = `decimal(${field.precision ?? 'undefined'}, ${field.scale ?? 'undefined'})`;
+              break;
+            default:
+              throw new Error(`Generated columns of kind ${kind} and type ${field.type} are not supported yet.`);
+          }
+          break;
+        default:
+          throw new Error(`Generated columns of kind ${kind} are not supported yet.`);
+      }
+      if (index) {
+        this.writer.write(`,`);
+      }
+      if (alter) {
+        this.writer.write(` ALTER COLUMN "${name}" TYPE ${type}`);
+        if (setNonNull) {
+          if (nonNull()) {
+            this.writer.write(`, ALTER COLUMN "${name}" SET NOT NULL`);
+          } else {
+            this.writer.write(`, ALTER COLUMN "${name}" DROP NOT NULL`);
+          }
+        }
+        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}) STORED`,
+        );
+      }
+
+      return;
+    }
+
+    throw new Error(`Only generated columns can be created with columnRaw`);
+  }
+
   private column(
     { name, primary, list, ...field }: EntityField,
     { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {},
     toColumn?: Column,
   ) {
-    const col = (what?: string) => {
-      if (what) {
-        this.writer.write(what);
-      }
+    const nonNull = () => {
       if (setNonNull) {
         if (toColumn) {
           if (toColumn.is_nullable) {
-            this.writer.write(`.nullable()`);
-          } else {
-            this.writer.write('.notNullable()');
-          }
-        } else {
-          if (field.nonNull) {
-            this.writer.write(`.notNullable()`);
-          } else {
-            this.writer.write('.nullable()');
+            return false;
           }
+
+          return true;
         }
+        if (field.nonNull) {
+          return true;
+        }
+
+        return false;
+      }
+    };
+    const kind = field.kind;
+    if (field.generateAs) {
+      let type = '';
+      switch (kind) {
+        case undefined:
+        case 'primitive':
+          switch (field.type) {
+            case 'Float':
+              type = `decimal(${field.precision ?? 'undefined'}, ${field.scale ?? 'undefined'})`;
+              break;
+            default:
+              throw new Error(`Generated columns of kind ${kind} and type ${field.type} are not supported yet.`);
+          }
+          break;
+        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')`,
+      );
+      if (alter) {
+        this.writer.write('.alter()');
+      }
+      this.writer.write(';').newLine();
+
+      return;
+    }
+
+    const col = (what?: string) => {
+      if (what) {
+        this.writer.write(what);
+      }
+      if (setNonNull) {
+        this.writer.write(nonNull() ? '.notNullable()' : '.nullable()');
       }
       if (setDefault && field.defaultValue !== undefined) {
         this.writer.write(`.defaultTo(${this.value(field.defaultValue)})`);
@@ -642,7 +790,6 @@ export class MigrationGenerator {
       }
       this.writer.write(';').newLine();
     };
-    const kind = field.kind;
     switch (kind) {
       case undefined:
       case 'primitive':
@@ -716,6 +863,44 @@ export class MigrationGenerator {
   private getColumn(tableName: string, columnName: string) {
     return this.columns[tableName].find((col) => col.name === columnName);
   }
+
+  private hasChanged(model: EntityModel, field: EntityField) {
+    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 ((!field.nonNull && !col.is_nullable) || (field.nonNull && col.is_nullable)) {
+      return true;
+    }
+
+    if (!field.kind || field.kind === 'primitive') {
+      if (field.type === 'Int') {
+        if (col.data_type !== 'integer') {
+          return true;
+        }
+      }
+      if (field.type === 'Float') {
+        if (field.double) {
+          if (col.data_type !== 'double precision') {
+            return true;
+          }
+        } else if (col.data_type !== 'numeric') {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
 }
 
 export const getMigrationDate = () => {

package/src/models/model-definitions.ts

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

package/src/permissions/check.ts

@@ -152,7 +152,7 @@ export const checkCanWrite = async (
     throw new PermissionError(getRole(ctx), action, model.plural, 'no applicable permissions');
   }
 
-  const query = ctx.knex.select(1 as any).first();
+  const query = ctx.knex.first();
   let linked = false;
 
   for (const field of model.fields.filter(
@@ -183,7 +183,9 @@ export const checkCanWrite = async (
       if (fieldPermissionStack === true) {
         // User can link any entity from this type, just check whether it exists
 
-        query.whereExists((subQuery) => subQuery.from(`${field.type} as a`).whereRaw(`a.id = ?`, foreignId));
+        query.select(
+          ctx.knex.raw(`EXISTS(SELECT 1 FROM ?? as a WHERE a.id = ?) as ??`, [field.type, foreignId, foreignKey]),
+        );
         continue;
       }
 
@@ -196,10 +198,16 @@ export const checkCanWrite = async (
         );
       }
 
-      ors(
-        query,
-        fieldPermissionStack.map(
-          (links) => (query) => query.whereExists((subQuery) => permissionLinkQuery(ctx, subQuery, links, foreignId)),
+      query.select(
+        ctx.knex.raw(
+          `${fieldPermissionStack
+            .map((links) => {
+              const subQuery = ctx.knex.queryBuilder();
+              permissionLinkQuery(ctx, subQuery, links, foreignId);
+
+              return `EXISTS(${subQuery.toString()})`;
+            })
+            .join(' OR ')} as "${foreignKey}"`,
         ),
       );
     }
@@ -211,8 +219,14 @@ export const checkCanWrite = async (
       console.debug('QUERY', query.toString());
     }
     const canMutate = await query;
-    if (!canMutate) {
-      throw new PermissionError(role, action, `this ${model.name}`, 'no linkable entities');
+    const cannotLink = Object.entries(canMutate).filter(([, value]) => !value);
+    if (cannotLink.length) {
+      throw new PermissionError(
+        role,
+        action,
+        `this ${model.name}`,
+        `cannot link to ${cannotLink.map(([key]) => `${key}: ${data[key]}`).join(', ')}`,
+      );
     }
   } else if (action === 'CREATE') {
     throw new PermissionError(role, action, `this ${model.name}`, 'no linkable entities');