@tachybase/plugin-field-sequence 0.23.8

package/dist/server/Plugin.js

@@ -0,0 +1,124 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Plugin_exports = {};
+__export(Plugin_exports, {
+  default: () => SequenceFieldPlugin
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_crypto = require("crypto");
+var import_path = __toESM(require("path"));
+var import_util = require("util");
+var import_server = require("@tachybase/server");
+var import_utils = require("@tachybase/utils");
+var import_field_sequence = require("./fields/field-sequence");
+const asyncRandomInt = (0, import_util.promisify)(import_crypto.randomInt);
+class SequenceFieldPlugin extends import_server.Plugin {
+  patternTypes = new import_utils.Registry();
+  async load() {
+    const { app, db, options } = this;
+    db.registerFieldTypes({
+      sequence: import_field_sequence.SequenceField
+    });
+    db.addMigrations({
+      namespace: "field-sequence",
+      directory: import_path.default.resolve(__dirname, "migrations"),
+      context: {
+        plugin: this
+      }
+    });
+    await this.importCollections(import_path.default.resolve(__dirname, "collections"));
+    db.on("fields.beforeSave", async (field, { transaction }) => {
+      if (field.get("type") !== "sequence") {
+        return;
+      }
+      const patterns = (field.get("patterns") || []).filter((p) => p.type === "integer");
+      if (!patterns.length) {
+        return;
+      }
+      const SequenceRepo = db.getRepository("sequences");
+      await patterns.reduce(
+        (promise, p) => promise.then(async () => {
+          var _a;
+          if (((_a = p.options) == null ? void 0 : _a.key) == null) {
+            Object.assign(p, {
+              options: {
+                ...p.options,
+                key: await asyncRandomInt(1 << 16)
+              }
+            });
+          }
+        }),
+        Promise.resolve()
+      );
+      const sequences = await SequenceRepo.find({
+        filter: {
+          field: field.get("name"),
+          collection: field.get("collectionName"),
+          key: patterns.map((p) => p.options.key)
+        },
+        transaction
+      });
+      await patterns.reduce(
+        (promise, p) => promise.then(async () => {
+          if (!sequences.find((s) => s.get("key") === p.options.key)) {
+            await SequenceRepo.create({
+              values: {
+                field: field.get("name"),
+                collection: field.get("collectionName"),
+                key: p.options.key
+              },
+              transaction
+            });
+            await field.load({ transaction });
+          }
+        }),
+        Promise.resolve()
+      );
+    });
+    db.on("fields.afterDestroy", async (field, { transaction }) => {
+      if (field.get("type") !== "sequence") {
+        return;
+      }
+      const patterns = (field.get("patterns") || []).filter((p) => p.type === "integer");
+      if (!patterns.length) {
+        return;
+      }
+      const SequenceRepo = db.getRepository("sequences");
+      await SequenceRepo.destroy({
+        filter: {
+          field: field.get("name"),
+          collection: field.get("collectionName"),
+          key: patterns.map((p) => p.key)
+        },
+        transaction
+      });
+    });
+  }
+  async install() {
+  }
+}

package/dist/server/collections/sequences.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tachybase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/sequences.js

@@ -0,0 +1,87 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sequences_exports = {};
+__export(sequences_exports, {
+  default: () => sequences_default
+});
+module.exports = __toCommonJS(sequences_exports);
+var import_database = require("@tachybase/database");
+var sequences_default = (0, import_database.defineCollection)({
+  dumpRules: {
+    group: "required",
+    async delayRestore(restorer) {
+      const app = restorer.app;
+      const importedCollections = restorer.importedCollections;
+      const sequenceFields = importedCollections.map((collection) => {
+        const collectionInstance = app.db.getCollection(collection);
+        if (!collectionInstance) throw new Error(`Collection ${collection} not found`);
+        return [...collectionInstance.fields.values()].filter((field) => field.type === "sequence");
+      }).flat().filter(Boolean);
+      const sequencesAttributes = sequenceFields.map((field) => {
+        const patterns = field.get("patterns");
+        return patterns.map((pattern) => {
+          return {
+            collection: field.collection.name,
+            field: field.name,
+            key: pattern.options.key
+          };
+        });
+      }).flat().filter((attr) => attr.collection && attr.field && attr.key);
+      if (sequencesAttributes.length > 0) {
+        await app.db.getRepository("sequences").destroy({
+          filter: {
+            $or: sequencesAttributes
+          }
+        });
+      }
+      await restorer.importCollection({
+        name: "sequences",
+        clear: false,
+        rowCondition(row) {
+          return sequencesAttributes.some((attributes) => {
+            return row.collection === attributes.collection && row.field === attributes.field && row.key === attributes.key;
+          });
+        }
+      });
+    }
+  },
+  name: "sequences",
+  shared: true,
+  fields: [
+    {
+      name: "collection",
+      type: "string"
+    },
+    {
+      name: "field",
+      type: "string"
+    },
+    {
+      name: "key",
+      type: "integer"
+    },
+    {
+      name: "current",
+      type: "bigInt"
+    },
+    {
+      name: "lastGeneratedAt",
+      type: "date"
+    }
+  ]
+});

package/dist/server/fields/field-sequence.d.ts

@@ -0,0 +1,38 @@
+import { BaseColumnFieldOptions, DataTypes, Field, FieldContext, Model, Transactionable } from '@tachybase/database';
+import { Registry } from '@tachybase/utils';
+export interface Pattern {
+    validate?(options: any): string | null;
+    generate(this: SequenceField, instance: Model, opts: {
+        [key: string]: any;
+    }, options: Transactionable): Promise<string> | string;
+    batchGenerate(this: SequenceField, instances: Model[], values: string[], opts: {
+        [key: string]: any;
+    }, options: Transactionable): Promise<void> | void;
+    getLength(options: any): number;
+    getMatcher(options: any): string;
+    update?(this: SequenceField, instance: Model, value: string, options: any, transactionable: Transactionable): Promise<void>;
+}
+export declare const sequencePatterns: Registry<Pattern>;
+interface PatternConfig {
+    type: string;
+    title?: string;
+    options?: any;
+}
+export interface SequenceFieldOptions extends BaseColumnFieldOptions {
+    type: 'sequence';
+    patterns: PatternConfig[];
+}
+export declare class SequenceField extends Field {
+    matcher: RegExp;
+    get dataType(): DataTypes.StringDataTypeConstructor;
+    constructor(options: SequenceFieldOptions, context: FieldContext);
+    validate: (instance: Model) => void;
+    setValue: (instance: Model, options: any) => Promise<void>;
+    setGroupValue: (instances: Model[], options: any) => Promise<void>;
+    cleanHook: (_: any, options: any) => void;
+    match(value: any): RegExpMatchArray;
+    update(instance: Model, options: any): Promise<void>;
+    bind(): void;
+    unbind(): void;
+}
+export {};

package/dist/server/fields/field-sequence.js

@@ -0,0 +1,386 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var field_sequence_exports = {};
+__export(field_sequence_exports, {
+  SequenceField: () => SequenceField,
+  sequencePatterns: () => sequencePatterns
+});
+module.exports = __toCommonJS(field_sequence_exports);
+var import_database = require("@tachybase/database");
+var import_utils = require("@tachybase/utils");
+var import_cron_parser = __toESM(require("cron-parser"));
+var import_dayjs = __toESM(require("dayjs"));
+var import_lodash = __toESM(require("lodash"));
+const sequencePatterns = new import_utils.Registry();
+sequencePatterns.register("string", {
+  validate(options) {
+    if (!(options == null ? void 0 : options.value)) {
+      return "options.value should be configured as a non-empty string";
+    }
+    return null;
+  },
+  generate(instance, options) {
+    return options.value;
+  },
+  batchGenerate(instances, values, options) {
+    instances.forEach((instance, i) => {
+      values[i] = options.value;
+    });
+  },
+  getLength(options) {
+    return options.value.length;
+  },
+  getMatcher(options) {
+    return import_lodash.default.escapeRegExp(options.value);
+  }
+});
+sequencePatterns.register("integer", {
+  // validate(options) {
+  //   if (!options?.key) {
+  //     return 'options.key should be configured as an integer';
+  //   }
+  //   return null;
+  // },
+  async generate(instance, options, { transaction }) {
+    const recordTime = instance.get("createdAt") ?? /* @__PURE__ */ new Date();
+    const { digits = 1, start = 0, base = 10, cycle, key } = options;
+    const { repository: SeqRepo, model: SeqModel } = this.database.getCollection("sequences");
+    const lastSeq = await SeqRepo.findOne({
+      filter: {
+        collection: this.collection.name,
+        field: this.name,
+        key
+      },
+      transaction
+    }) || SeqModel.build({
+      collection: this.collection.name,
+      field: this.name,
+      key
+    });
+    let next = start;
+    if (lastSeq.get("current") != null) {
+      next = Math.max(lastSeq.get("current") + 1, start);
+      const max = Math.pow(base, digits) - 1;
+      if (next > max) {
+        next = start;
+      }
+      if (cycle) {
+        const interval = import_cron_parser.default.parseExpression(cycle, { currentDate: lastSeq.get("lastGeneratedAt") });
+        const nextTime = interval.next();
+        if (recordTime.getTime() >= nextTime.getTime()) {
+          next = start;
+        }
+      }
+    }
+    lastSeq.set({
+      current: next,
+      lastGeneratedAt: recordTime
+    });
+    await lastSeq.save({ transaction });
+    return next.toString(base).padStart(digits, "0");
+  },
+  getLength({ digits = 1 } = {}) {
+    return digits;
+  },
+  getMatcher(options = {}) {
+    const { digits = 1, base = 10 } = options;
+    const chars = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, base);
+    return `[${chars}]{${digits}}`;
+  },
+  async batchGenerate(instances, values, options, { transaction }) {
+    const { name, patterns } = this.options;
+    const { digits = 1, start = 0, base = 10, cycle, key } = options;
+    const { repository: SeqRepo, model: SeqModel } = this.database.getCollection("sequences");
+    const lastSeq = await SeqRepo.findOne({
+      filter: {
+        collection: this.collection.name,
+        field: this.name,
+        key
+      },
+      transaction
+    }) || SeqModel.build({
+      collection: this.collection.name,
+      field: this.name,
+      key
+    });
+    instances.forEach((instance, i) => {
+      const recordTime = instance.get("createdAt") ?? /* @__PURE__ */ new Date();
+      const value = instance.get(name);
+      if (value != null && this.options.inputable) {
+        const matcher = this.match(value);
+        if (matcher) {
+          const patternIndex = patterns.indexOf(options);
+          const number = Number.parseInt(matcher[patternIndex + 1], base);
+          if (lastSeq.get("current") == null) {
+            lastSeq.set({
+              current: number,
+              lastGeneratedAt: recordTime
+            });
+          } else {
+            if (number > lastSeq.get("current")) {
+              lastSeq.set({
+                current: number,
+                lastGeneratedAt: recordTime
+              });
+            }
+          }
+        }
+      } else {
+        let next = start;
+        if (lastSeq.get("current") != null) {
+          next = Math.max(lastSeq.get("current") + 1, start);
+          const max = Math.pow(base, digits) - 1;
+          if (next > max) {
+            next = start;
+          }
+          if (cycle) {
+            const interval = import_cron_parser.default.parseExpression(cycle, { currentDate: lastSeq.get("lastGeneratedAt") });
+            const nextTime = interval.next();
+            if (recordTime.getTime() >= nextTime.getTime()) {
+              next = start;
+            }
+          }
+        }
+        lastSeq.set({
+          current: next,
+          lastGeneratedAt: recordTime
+        });
+        values[i] = next.toString(base).padStart(digits, "0");
+      }
+    });
+    await lastSeq.save({ transaction });
+  },
+  async update(instance, value, options, { transaction }) {
+    const recordTime = instance.get("createdAt") ?? /* @__PURE__ */ new Date();
+    const { digits = 1, start = 0, base = 10, cycle, key } = options;
+    const SeqRepo = this.database.getRepository("sequences");
+    const lastSeq = await SeqRepo.findOne({
+      filter: {
+        collection: this.collection.name,
+        field: this.name,
+        key
+      },
+      transaction
+    });
+    const current = Number.parseInt(value, base);
+    if (!lastSeq) {
+      return SeqRepo.create({
+        values: {
+          collection: this.collection.name,
+          field: this.name,
+          key,
+          current,
+          lastGeneratedAt: recordTime
+        },
+        transaction
+      });
+    }
+    if (lastSeq.get("current") == null) {
+      return lastSeq.update(
+        {
+          current,
+          lastGeneratedAt: recordTime
+        },
+        { transaction }
+      );
+    }
+    if (cycle) {
+      const interval = import_cron_parser.default.parseExpression(cycle, { currentDate: lastSeq.get("lastGeneratedAt") });
+      const nextTime = interval.next();
+      if (recordTime.getTime() >= nextTime.getTime()) {
+        lastSeq.set({
+          current,
+          lastGeneratedAt: recordTime
+        });
+      } else {
+        if (current > lastSeq.get("current")) {
+          lastSeq.set({
+            current,
+            lastGeneratedAt: recordTime
+          });
+        }
+      }
+    } else {
+      if (current > lastSeq.get("current")) {
+        lastSeq.set({
+          current,
+          lastGeneratedAt: recordTime
+        });
+      }
+    }
+    return lastSeq.save({ transaction });
+  }
+});
+sequencePatterns.register("date", {
+  generate(instance, options) {
+    return (0, import_dayjs.default)(instance.get((options == null ? void 0 : options.field) ?? "createdAt")).format((options == null ? void 0 : options.format) ?? "YYYYMMDD");
+  },
+  batchGenerate(instances, values, options) {
+    const { field, inputable } = options;
+    instances.forEach((instance, i) => {
+      if (!inputable || instance.get(field ?? "createdAt") == null) {
+        values[i] = sequencePatterns.get("date").generate.call(this, instance, options);
+      }
+    });
+  },
+  getLength(options) {
+    var _a;
+    return ((_a = options.format) == null ? void 0 : _a.length) ?? 8;
+  },
+  getMatcher(options = {}) {
+    var _a;
+    return `.{${((_a = options == null ? void 0 : options.format) == null ? void 0 : _a.length) ?? 8}}`;
+  }
+});
+class SequenceField extends import_database.Field {
+  matcher;
+  get dataType() {
+    return import_database.DataTypes.STRING;
+  }
+  constructor(options, context) {
+    super(options, context);
+    if (!options.patterns || !options.patterns.length) {
+      throw new Error("at least one pattern should be defined for sequence type");
+    }
+    options.patterns.forEach((pattern) => {
+      const P = sequencePatterns.get(pattern.type);
+      if (!P) {
+        throw new Error(`pattern type ${pattern.type} is not registered`);
+      }
+      if (P.validate) {
+        const error = P.validate(pattern.options);
+        if (error) {
+          throw new Error(error);
+        }
+      }
+    });
+    const patterns = options.patterns.map(({ type, options: options2 }) => sequencePatterns.get(type).getMatcher(options2));
+    this.matcher = new RegExp(`^${patterns.map((p) => `(${p})`).join("")}$`, "i");
+  }
+  validate = (instance) => {
+    const { name, inputable, match } = this.options;
+    const value = instance.get(name);
+    if (value != null && inputable && match && !this.match(value)) {
+      throw new import_database.ValidationError("sequence pattern not match", [
+        new import_database.ValidationErrorItem(
+          `input value of ${name} field not match the sequence pattern (${this.matcher.toString()}) which is required`,
+          "validation error",
+          // NOTE: type should only be this which in sequelize enum set
+          name,
+          value,
+          instance,
+          "sequence_pattern_not_match",
+          name,
+          []
+        )
+      ]);
+    }
+  };
+  setValue = async (instance, options) => {
+    var _a;
+    if ((_a = options.skipIndividualHooks) == null ? void 0 : _a.has(`${this.collection.name}.beforeCreate.${this.name}`)) {
+      return;
+    }
+    const { name, patterns, inputable } = this.options;
+    const value = instance.get(name);
+    if (value != null && inputable) {
+      return this.update(instance, options);
+    }
+    const results = await patterns.reduce(
+      (promise, p) => promise.then(async (result) => {
+        const item = await sequencePatterns.get(p.type).generate.call(this, instance, p.options, options);
+        return result.concat(item);
+      }),
+      Promise.resolve([])
+    );
+    instance.set(name, results.join(""));
+  };
+  setGroupValue = async (instances, options) => {
+    if (!instances.length) {
+      return;
+    }
+    if (!options.skipIndividualHooks) {
+      options.skipIndividualHooks = /* @__PURE__ */ new Set();
+    }
+    options.skipIndividualHooks.add(`${this.collection.name}.beforeCreate.${this.name}`);
+    const { name, patterns, inputable } = this.options;
+    const array = Array(patterns.length).fill(null).map(() => Array(instances.length));
+    await patterns.reduce(
+      (promise, p, i) => promise.then(
+        () => sequencePatterns.get(p.type).batchGenerate.call(this, instances, array[i], p.options ?? {}, options)
+      ),
+      Promise.resolve()
+    );
+    instances.forEach((instance, i) => {
+      const value = instance.get(name);
+      if (!inputable || value == null) {
+        instance.set(this.name, array.map((a) => a[i]).join(""));
+      }
+    });
+  };
+  cleanHook = (_, options) => {
+    options.skipIndividualHooks.delete(`${this.collection.name}.beforeCreate.${this.name}`);
+  };
+  match(value) {
+    return typeof value === "string" ? value.match(this.matcher) : null;
+  }
+  async update(instance, options) {
+    const { name, patterns } = this.options;
+    const matched = this.match(instance.get(name));
+    if (matched) {
+      await matched.slice(1).map((_, i) => sequencePatterns.get(patterns[i].type).update).reduce(
+        (promise, update, i) => promise.then(() => {
+          if (!update) {
+            return;
+          }
+          return update.call(this, instance, matched[i + 1], patterns[i].options, options);
+        }),
+        Promise.resolve()
+      );
+    }
+  }
+  bind() {
+    super.bind();
+    this.on("beforeValidate", this.validate);
+    this.on("beforeCreate", this.setValue);
+    this.on("beforeBulkCreate", this.setGroupValue);
+    this.on("afterBulkCreate", this.cleanHook);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeValidate", this.validate);
+    this.off("beforeCreate", this.setValue);
+    this.off("beforeBulkCreate", this.setGroupValue);
+    this.off("afterBulkCreate", this.cleanHook);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SequenceField,
+  sequencePatterns
+});

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fields/field-sequence';
+export { default } from './Plugin';

package/dist/server/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  default: () => import_Plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("./fields/field-sequence"), module.exports);
+var import_Plugin = __toESM(require("./Plugin"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./fields/field-sequence")
+});

package/dist/server/migrations/20221207022250-sequence-field-key.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}