@smartive/graphql-magic 22.3.0 → 22.4.0

package/CHANGELOG.md

@@ -1,4 +1,5 @@
-## 22.3.0 (2025-12-03)
+## 22.4.0 (2025-12-10)
 
-* feat: Add query debugging (#384) ([5288cb6](https://github.com/smartive/graphql-magic/commit/5288cb6)), closes [#384](https://github.com/smartive/graphql-magic/issues/384)
-* chore(deps): update dependency del-cli to v7 (#354) ([3f466b5](https://github.com/smartive/graphql-magic/commit/3f466b5)), closes [#354](https://github.com/smartive/graphql-magic/issues/354)
+* feat: Generated fields (#390) ([f55e260](https://github.com/smartive/graphql-magic/commit/f55e260)), closes [#390](https://github.com/smartive/graphql-magic/issues/390)
+* chore(deps): update dependency esbuild to v0.27.1 (#394) ([b89fcab](https://github.com/smartive/graphql-magic/commit/b89fcab)), closes [#394](https://github.com/smartive/graphql-magic/issues/394)
+* chore(deps): update dependency prettier to v3.7.4 (#395) ([ec058d1](https://github.com/smartive/graphql-magic/commit/ec058d1)), closes [#395](https://github.com/smartive/graphql-magic/issues/395)

package/dist/bin/gqm.cjs

@@ -849,32 +849,23 @@ var MigrationGenerator = class {
             up,
             down
           );
-          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);
         }
         if (isUpdatableModel(model)) {
@@ -1017,6 +1008,9 @@ var MigrationGenerator = class {
       const postAlter = [];
       for (const field of fields2) {
         alter.push(() => this.column(field, { setNonNull: field.defaultValue !== void 0 }));
+        if (field.generateAs) {
+          continue;
+        }
         if (field.nonNull && field.defaultValue === void 0) {
           updates.push(() => this.writer.write(`${field.name}: 'TODO',`).newLine());
           postAlter.push(() => this.column(field, { alter: true, foreign: false }));
@@ -1040,12 +1034,56 @@ var MigrationGenerator = class {
     });
     down.push(() => {
       this.alterTable(model.name, () => {
-        for (const { kind, name: name2 } of fields2) {
+        for (const { kind, name: name2 } of fields2.toReversed()) {
           this.dropColumn(kind === "relation" ? `${name2}Id` : name2);
         }
       });
     });
   }
+  updateFieldsRaw(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
+    }
+    up.push(() => {
+      this.alterTableRaw(model.name, () => {
+        for (const [index, field] of fields2.entries()) {
+          this.columnRaw(field, { alter: true }, index);
+        }
+      });
+    });
+    down.push(() => {
+      this.alterTableRaw(model.name, () => {
+        for (const [index, field] of fields2.entries()) {
+          this.columnRaw(field, { alter: true }, index);
+        }
+      });
+    });
+    if (isUpdatableModel(model)) {
+      const updatableFields = fields2.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)
+            );
+          }
+        });
+      });
+    }
+  }
   updateFields(model, fields2, up, down) {
     if (!fields2.length) {
       return;
@@ -1166,6 +1204,11 @@ var MigrationGenerator = class {
   createTable(table, block) {
     return this.writer.write(`await knex.schema.createTable('${table}', (table) => `).inlineBlock(block).write(");").newLine().blankLine();
   }
+  alterTableRaw(table, block) {
+    this.writer.write(`await knex.raw('ALTER TABLE "${table}"`);
+    block();
+    this.writer.write(`');`).newLine().blankLine();
+  }
   alterTable(table, block) {
     return this.writer.write(`await knex.schema.alterTable('${table}', (table) => `).inlineBlock(block).write(");").newLine().blankLine();
   }
@@ -1187,25 +1230,107 @@ var MigrationGenerator = class {
     }
     return value2;
   }
-  column({ name: name2, primary, list: list2, ...field }, { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {}, toColumn) {
-    const col = (what) => {
-      if (what) {
-        this.writer.write(what);
-      }
+  columnRaw({ name: name2, ...field }, { setNonNull = true, alter = false } = {}, index, toColumn) {
+    const nonNull2 = () => {
       if (setNonNull) {
         if (toColumn) {
           if (toColumn.is_nullable) {
-            this.writer.write(`.nullable()`);
-          } else {
-            this.writer.write(".notNullable()");
+            return false;
           }
-        } else {
-          if (field.nonNull) {
-            this.writer.write(`.notNullable()`);
+          return true;
+        }
+        if (field.nonNull) {
+          return true;
+        }
+        return false;
+      }
+    };
+    const kind = field.kind;
+    if (field.generateAs) {
+      let type = "";
+      switch (kind) {
+        case void 0:
+        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 "${name2}" TYPE ${type}`);
+        if (setNonNull) {
+          if (nonNull2()) {
+            this.writer.write(`, ALTER COLUMN "${name2}" SET NOT NULL`);
           } else {
-            this.writer.write(".nullable()");
+            this.writer.write(`, ALTER COLUMN "${name2}" DROP NOT NULL`);
+          }
+        }
+        this.writer.write(`, ALTER COLUMN "${name2}" SET EXPRESSION AS (${field.generateAs})`);
+      } else {
+        this.writer.write(
+          `${alter ? "ALTER" : "ADD"} COLUMN "${name2}" ${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs}) STORED`
+        );
+      }
+      return;
+    }
+    throw new Error(`Only generated columns can be created with columnRaw`);
+  }
+  column({ name: name2, primary, list: list2, ...field }, { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {}, toColumn) {
+    const nonNull2 = () => {
+      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 void 0:
+        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('${name2}', '${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs}) STORED')`
+      );
+      if (alter) {
+        this.writer.write(".alter()");
+      }
+      this.writer.write(";").newLine();
+      return;
+    }
+    const col = (what) => {
+      if (what) {
+        this.writer.write(what);
+      }
+      if (setNonNull) {
+        this.writer.write(nonNull2() ? ".notNullable()" : ".nullable()");
       }
       if (setDefault && field.defaultValue !== void 0) {
         this.writer.write(`.defaultTo(${this.value(field.defaultValue)})`);
@@ -1220,7 +1345,6 @@ var MigrationGenerator = class {
       }
       this.writer.write(";").newLine();
     };
-    const kind = field.kind;
     switch (kind) {
       case void 0:
       case "primitive":
@@ -1290,6 +1414,39 @@ var MigrationGenerator = class {
   getColumn(tableName, columnName) {
     return this.columns[tableName].find((col) => col.name === columnName);
   }
+  hasChanged(model, field) {
+    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;
+  }
 };
 var getMigrationDate = () => {
   const date = /* @__PURE__ */ new Date();

package/dist/cjs/index.cjs

@@ -1213,32 +1213,23 @@ var MigrationGenerator = class {
             up,
             down
           );
-          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);
         }
         if (isUpdatableModel(model)) {
@@ -1381,6 +1372,9 @@ var MigrationGenerator = class {
       const postAlter = [];
       for (const field of fields2) {
         alter.push(() => this.column(field, { setNonNull: field.defaultValue !== void 0 }));
+        if (field.generateAs) {
+          continue;
+        }
         if (field.nonNull && field.defaultValue === void 0) {
           updates.push(() => this.writer.write(`${field.name}: 'TODO',`).newLine());
           postAlter.push(() => this.column(field, { alter: true, foreign: false }));
@@ -1404,12 +1398,56 @@ var MigrationGenerator = class {
     });
     down.push(() => {
       this.alterTable(model.name, () => {
-        for (const { kind, name: name2 } of fields2) {
+        for (const { kind, name: name2 } of fields2.toReversed()) {
           this.dropColumn(kind === "relation" ? `${name2}Id` : name2);
         }
       });
     });
   }
+  updateFieldsRaw(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
+    }
+    up.push(() => {
+      this.alterTableRaw(model.name, () => {
+        for (const [index, field] of fields2.entries()) {
+          this.columnRaw(field, { alter: true }, index);
+        }
+      });
+    });
+    down.push(() => {
+      this.alterTableRaw(model.name, () => {
+        for (const [index, field] of fields2.entries()) {
+          this.columnRaw(field, { alter: true }, index);
+        }
+      });
+    });
+    if (isUpdatableModel(model)) {
+      const updatableFields = fields2.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)
+            );
+          }
+        });
+      });
+    }
+  }
   updateFields(model, fields2, up, down) {
     if (!fields2.length) {
       return;
@@ -1530,6 +1568,11 @@ var MigrationGenerator = class {
   createTable(table, block) {
     return this.writer.write(`await knex.schema.createTable('${table}', (table) => `).inlineBlock(block).write(");").newLine().blankLine();
   }
+  alterTableRaw(table, block) {
+    this.writer.write(`await knex.raw('ALTER TABLE "${table}"`);
+    block();
+    this.writer.write(`');`).newLine().blankLine();
+  }
   alterTable(table, block) {
     return this.writer.write(`await knex.schema.alterTable('${table}', (table) => `).inlineBlock(block).write(");").newLine().blankLine();
   }
@@ -1551,25 +1594,107 @@ var MigrationGenerator = class {
     }
     return value2;
   }
-  column({ name: name2, primary, list: list2, ...field }, { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {}, toColumn) {
-    const col = (what) => {
-      if (what) {
-        this.writer.write(what);
-      }
+  columnRaw({ name: name2, ...field }, { setNonNull = true, alter = false } = {}, index, toColumn) {
+    const nonNull2 = () => {
       if (setNonNull) {
         if (toColumn) {
           if (toColumn.is_nullable) {
-            this.writer.write(`.nullable()`);
-          } else {
-            this.writer.write(".notNullable()");
+            return false;
           }
-        } else {
-          if (field.nonNull) {
-            this.writer.write(`.notNullable()`);
+          return true;
+        }
+        if (field.nonNull) {
+          return true;
+        }
+        return false;
+      }
+    };
+    const kind = field.kind;
+    if (field.generateAs) {
+      let type = "";
+      switch (kind) {
+        case void 0:
+        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 "${name2}" TYPE ${type}`);
+        if (setNonNull) {
+          if (nonNull2()) {
+            this.writer.write(`, ALTER COLUMN "${name2}" SET NOT NULL`);
           } else {
-            this.writer.write(".nullable()");
+            this.writer.write(`, ALTER COLUMN "${name2}" DROP NOT NULL`);
           }
         }
+        this.writer.write(`, ALTER COLUMN "${name2}" SET EXPRESSION AS (${field.generateAs})`);
+      } else {
+        this.writer.write(
+          `${alter ? "ALTER" : "ADD"} COLUMN "${name2}" ${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs}) STORED`
+        );
+      }
+      return;
+    }
+    throw new Error(`Only generated columns can be created with columnRaw`);
+  }
+  column({ name: name2, primary, list: list2, ...field }, { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {}, toColumn) {
+    const nonNull2 = () => {
+      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 void 0:
+        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('${name2}', '${type}${nonNull2() ? " not null" : ""} GENERATED ALWAYS AS (${field.generateAs}) STORED')`
+      );
+      if (alter) {
+        this.writer.write(".alter()");
+      }
+      this.writer.write(";").newLine();
+      return;
+    }
+    const col = (what) => {
+      if (what) {
+        this.writer.write(what);
+      }
+      if (setNonNull) {
+        this.writer.write(nonNull2() ? ".notNullable()" : ".nullable()");
       }
       if (setDefault && field.defaultValue !== void 0) {
         this.writer.write(`.defaultTo(${this.value(field.defaultValue)})`);
@@ -1584,7 +1709,6 @@ var MigrationGenerator = class {
       }
       this.writer.write(";").newLine();
     };
-    const kind = field.kind;
     switch (kind) {
       case void 0:
       case "primitive":
@@ -1654,6 +1778,39 @@ var MigrationGenerator = class {
   getColumn(tableName, columnName) {
     return this.columns[tableName].find((col) => col.name === columnName);
   }
+  hasChanged(model, field) {
+    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;
+  }
 };
 var getMigrationDate = () => {
   const date = /* @__PURE__ */ new Date();

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

@@ -12,19 +12,23 @@ export declare class MigrationGenerator {
     generate(): Promise<string>;
     private renameFields;
     private createFields;
+    private updateFieldsRaw;
     private updateFields;
     private createRevisionTable;
     private createRevisionFields;
     private createEnums;
     private migration;
     private createTable;
+    private alterTableRaw;
     private alterTable;
     private dropColumn;
     private dropTable;
     private renameTable;
     private renameColumn;
     private value;
+    private columnRaw;
     private column;
     private getColumn;
+    private hasChanged;
 }
 export declare const getMigrationDate: () => string;