@smartive/graphql-magic 22.1.0 → 22.2.0-next.1

package/CHANGELOG.md

@@ -1,6 +1,10 @@
-## 22.1.0 (2025-11-05)
+## 22.2.0-next.1 (2025-12-02)
 
-* feat: enhance field validation logic in MigrationGenerator (#379) ([ac0067f](https://github.com/smartive/graphql-magic/commit/ac0067f)), closes [#379](https://github.com/smartive/graphql-magic/issues/379)
-* chore(deps): update dependency esbuild to v0.25.12 (#377) ([bc672e9](https://github.com/smartive/graphql-magic/commit/bc672e9)), closes [#377](https://github.com/smartive/graphql-magic/issues/377)
-* chore(deps): update dependency eslint to v9.39.0 (#376) ([14232f2](https://github.com/smartive/graphql-magic/commit/14232f2)), closes [#376](https://github.com/smartive/graphql-magic/issues/376)
-* chore(deps): update dependency eslint to v9.39.1 (#378) ([fbfbd77](https://github.com/smartive/graphql-magic/commit/fbfbd77)), closes [#378](https://github.com/smartive/graphql-magic/issues/378)
+* feat: generated fields and migration check ([d0a275c](https://github.com/smartive/graphql-magic/commit/d0a275c))
+* chore(deps): update dependency @types/lodash to v4.17.21 (#383) ([b0dd062](https://github.com/smartive/graphql-magic/commit/b0dd062)), closes [#383](https://github.com/smartive/graphql-magic/issues/383)
+* chore(deps): update dependency esbuild to v0.26.0 (#380) ([c3065d6](https://github.com/smartive/graphql-magic/commit/c3065d6)), closes [#380](https://github.com/smartive/graphql-magic/issues/380)
+* chore(deps): update dependency esbuild to v0.27.0 (#381) ([62cca2a](https://github.com/smartive/graphql-magic/commit/62cca2a)), closes [#381](https://github.com/smartive/graphql-magic/issues/381)
+* chore(deps): update dependency prettier to v3.7.1 (#385) ([680ed83](https://github.com/smartive/graphql-magic/commit/680ed83)), closes [#385](https://github.com/smartive/graphql-magic/issues/385)
+* chore(deps): update dependency prettier to v3.7.2 (#386) ([19e819d](https://github.com/smartive/graphql-magic/commit/19e819d)), closes [#386](https://github.com/smartive/graphql-magic/issues/386)
+* chore(deps): update dependency prettier to v3.7.3 (#387) ([73f2af9](https://github.com/smartive/graphql-magic/commit/73f2af9)), closes [#387](https://github.com/smartive/graphql-magic/issues/387)
+* chore(deps): update dependency ts-jest to v29.4.6 (#388) ([31776a8](https://github.com/smartive/graphql-magic/commit/31776a8)), closes [#388](https://github.com/smartive/graphql-magic/issues/388)

package/dist/bin/gqm.cjs

@@ -750,6 +750,7 @@ var MigrationGenerator = class {
   columns = {};
   uuidUsed;
   nowUsed;
+  needsMigration = false;
   async generate() {
     const { writer, schema, models } = this;
     const enums = (await schema.knex("pg_type").where({ typtype: "e" }).select("typname")).map(({ typname }) => typname);
@@ -848,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)) {
@@ -971,6 +963,9 @@ var MigrationGenerator = class {
     if (this.nowUsed) {
       writer.writeLine(`const now = date();`).blankLine();
     }
+    if (up.length || down.length) {
+      this.needsMigration = true;
+    }
     this.migration("up", up);
     this.migration("down", down.reverse());
     return writer.toString();
@@ -1013,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 }));
@@ -1036,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;
@@ -1162,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();
   }
@@ -1183,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)})`);
@@ -1216,7 +1345,6 @@ var MigrationGenerator = class {
       }
       this.writer.write(";").newLine();
     };
-    const kind = field.kind;
     switch (kind) {
       case void 0:
       case "primitive":
@@ -1286,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();
@@ -2497,6 +2658,21 @@ import_commander.program.command("generate-migration [<name>] [<date>]").descrip
     await db.destroy();
   }
 });
+import_commander.program.command("check-needs-migration").description("Check if a migration is needed").action(async () => {
+  const knexfile = await parseKnexfile();
+  const db = (0, import_knex.default)(knexfile);
+  try {
+    const models = await parseModels();
+    const mg = new MigrationGenerator(db, models);
+    await mg.generate();
+    if (mg.needsMigration) {
+      console.error("Migration is needed.");
+      process.exit(1);
+    }
+  } finally {
+    await db.destroy();
+  }
+});
 import_commander.program.command("*", { noHelp: true }).description("Invalid command").action(() => {
   console.error("Invalid command: %s\nSee --help for a list of available commands.", import_commander.program.args.join(" "));
   process.exit(1);

package/dist/cjs/index.cjs

@@ -1114,6 +1114,7 @@ var MigrationGenerator = class {
   columns = {};
   uuidUsed;
   nowUsed;
+  needsMigration = false;
   async generate() {
     const { writer, schema, models } = this;
     const enums = (await schema.knex("pg_type").where({ typtype: "e" }).select("typname")).map(({ typname }) => typname);
@@ -1212,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)) {
@@ -1335,6 +1327,9 @@ var MigrationGenerator = class {
     if (this.nowUsed) {
       writer.writeLine(`const now = date();`).blankLine();
     }
+    if (up.length || down.length) {
+      this.needsMigration = true;
+    }
     this.migration("up", up);
     this.migration("down", down.reverse());
     return writer.toString();
@@ -1377,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 }));
@@ -1400,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;
@@ -1526,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();
   }
@@ -1547,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)})`);
@@ -1580,7 +1709,6 @@ var MigrationGenerator = class {
       }
       this.writer.write(";").newLine();
     };
-    const kind = field.kind;
     switch (kind) {
       case void 0:
       case "primitive":
@@ -1650,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

@@ -7,23 +7,28 @@ export declare class MigrationGenerator {
     private columns;
     private uuidUsed?;
     private nowUsed?;
+    needsMigration: boolean;
     constructor(knex: Knex, models: Models);
     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;