@autofleet/sadot 1.6.18-beta.2 → 1.6.18-beta.21

package/dist/init-state.cjs

@@ -0,0 +1,56 @@
+
+//#region src/init-state.ts
+/**
+* Tracks the initialization state of sadot's useCustomFields function
+* Allows HealthManager to wait for initialization before passing readiness checks
+*/
+var SadotInitializationState = class {
+	constructor() {
+		this.initPromise = null;
+		this.initError = null;
+		this.isInitialized = false;
+		this.sequelizeInstance = null;
+		this.ownsSequelizeInstance = false;
+	}
+	/** Set the initialization promise */
+	setInitPromise(promise, ownsSequelize) {
+		this.initPromise = promise;
+		this.ownsSequelizeInstance = ownsSequelize;
+		promise.then((sequelize) => {
+			this.sequelizeInstance = sequelize;
+			this.isInitialized = true;
+		}, (error) => this.initError = error);
+	}
+	/**
+	* Get the Sequelize instance
+	* Returns null if initialization hasn't completed yet, or in cases where it failed.
+	*/
+	get sequelize() {
+		return this.sequelizeInstance;
+	}
+	/**
+	* Wait for initialization to complete and return the Sequelize instance
+	* Returns the Sequelize instance only if Sadot created it (owns it)
+	* Returns undefined if the Sequelize instance was provided externally
+	* Rejects when initialization fails
+	*/
+	async waitForInitialization() {
+		if (this.isInitialized && this.sequelizeInstance) return this.ownsSequelizeInstance ? this.sequelizeInstance : void 0;
+		if (this.initError) throw this.initError;
+		if (!this.initPromise) throw new Error("Sadot initialization has not started");
+		const sequelize = await this.initPromise;
+		if (this.initError) throw this.initError;
+		return this.ownsSequelizeInstance ? sequelize : void 0;
+	}
+	/** Check if initialization is complete and successful */
+	get isReady() {
+		return this.isInitialized && !this.initError;
+	}
+	/** Get the initialization error if one occurred */
+	get error() {
+		return this.initError;
+	}
+};
+
+//#endregion
+exports.SadotInitializationState = SadotInitializationState;

package/dist/init-state.d.cts

@@ -0,0 +1,35 @@
+import { Sequelize } from "sequelize-typescript";
+
+//#region src/init-state.d.ts
+
+/**
+* Tracks the initialization state of sadot's useCustomFields function
+* Allows HealthManager to wait for initialization before passing readiness checks
+*/
+declare class SadotInitializationState {
+  private initPromise;
+  private initError;
+  private isInitialized;
+  private sequelizeInstance;
+  private ownsSequelizeInstance;
+  /** Set the initialization promise */
+  setInitPromise(promise: Promise<Sequelize>, ownsSequelize: boolean): void;
+  /**
+  * Get the Sequelize instance
+  * Returns null if initialization hasn't completed yet, or in cases where it failed.
+  */
+  get sequelize(): Sequelize | null;
+  /**
+  * Wait for initialization to complete and return the Sequelize instance
+  * Returns the Sequelize instance only if Sadot created it (owns it)
+  * Returns undefined if the Sequelize instance was provided externally
+  * Rejects when initialization fails
+  */
+  waitForInitialization(): Promise<Sequelize | undefined>;
+  /** Check if initialization is complete and successful */
+  get isReady(): boolean;
+  /** Get the initialization error if one occurred */
+  get error(): Error | null;
+}
+//#endregion
+export { SadotInitializationState };

package/dist/init-state.d.ts

@@ -0,0 +1,35 @@
+import { Sequelize } from "sequelize-typescript";
+
+//#region src/init-state.d.ts
+
+/**
+* Tracks the initialization state of sadot's useCustomFields function
+* Allows HealthManager to wait for initialization before passing readiness checks
+*/
+declare class SadotInitializationState {
+  private initPromise;
+  private initError;
+  private isInitialized;
+  private sequelizeInstance;
+  private ownsSequelizeInstance;
+  /** Set the initialization promise */
+  setInitPromise(promise: Promise<Sequelize>, ownsSequelize: boolean): void;
+  /**
+  * Get the Sequelize instance
+  * Returns null if initialization hasn't completed yet, or in cases where it failed.
+  */
+  get sequelize(): Sequelize | null;
+  /**
+  * Wait for initialization to complete and return the Sequelize instance
+  * Returns the Sequelize instance only if Sadot created it (owns it)
+  * Returns undefined if the Sequelize instance was provided externally
+  * Rejects when initialization fails
+  */
+  waitForInitialization(): Promise<Sequelize | undefined>;
+  /** Check if initialization is complete and successful */
+  get isReady(): boolean;
+  /** Get the initialization error if one occurred */
+  get error(): Error | null;
+}
+//#endregion
+export { SadotInitializationState };

package/dist/init-state.js

@@ -0,0 +1,55 @@
+//#region src/init-state.ts
+/**
+* Tracks the initialization state of sadot's useCustomFields function
+* Allows HealthManager to wait for initialization before passing readiness checks
+*/
+var SadotInitializationState = class {
+	constructor() {
+		this.initPromise = null;
+		this.initError = null;
+		this.isInitialized = false;
+		this.sequelizeInstance = null;
+		this.ownsSequelizeInstance = false;
+	}
+	/** Set the initialization promise */
+	setInitPromise(promise, ownsSequelize) {
+		this.initPromise = promise;
+		this.ownsSequelizeInstance = ownsSequelize;
+		promise.then((sequelize) => {
+			this.sequelizeInstance = sequelize;
+			this.isInitialized = true;
+		}, (error) => this.initError = error);
+	}
+	/**
+	* Get the Sequelize instance
+	* Returns null if initialization hasn't completed yet, or in cases where it failed.
+	*/
+	get sequelize() {
+		return this.sequelizeInstance;
+	}
+	/**
+	* Wait for initialization to complete and return the Sequelize instance
+	* Returns the Sequelize instance only if Sadot created it (owns it)
+	* Returns undefined if the Sequelize instance was provided externally
+	* Rejects when initialization fails
+	*/
+	async waitForInitialization() {
+		if (this.isInitialized && this.sequelizeInstance) return this.ownsSequelizeInstance ? this.sequelizeInstance : void 0;
+		if (this.initError) throw this.initError;
+		if (!this.initPromise) throw new Error("Sadot initialization has not started");
+		const sequelize = await this.initPromise;
+		if (this.initError) throw this.initError;
+		return this.ownsSequelizeInstance ? sequelize : void 0;
+	}
+	/** Check if initialization is complete and successful */
+	get isReady() {
+		return this.isInitialized && !this.initError;
+	}
+	/** Get the initialization error if one occurred */
+	get error() {
+		return this.initError;
+	}
+};
+
+//#endregion
+export { SadotInitializationState };

package/dist/mat-path-state.cjs

@@ -0,0 +1,10 @@
+
+//#region src/mat-path-state.ts
+/**
+* Module-scoped holder for the optional `isMatPathEnabled` predicate so route handlers can
+* read it without threading the option through every layer. Set once during `useCustomFields()`.
+*/
+const matPathState = {};
+
+//#endregion
+exports.matPathState = matPathState;

package/dist/mat-path-state.js

@@ -0,0 +1,9 @@
+//#region src/mat-path-state.ts
+/**
+* Module-scoped holder for the optional `isMatPathEnabled` predicate so route handlers can
+* read it without threading the option through every layer. Set once during `useCustomFields()`.
+*/
+const matPathState = {};
+
+//#endregion
+export { matPathState };

package/dist/migrations/001-create-core-tables.cjs

@@ -0,0 +1,70 @@
+
+//#region src/migrations/001-create-core-tables.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_field_definitions" (
+      "id"                   UUID        NOT NULL DEFAULT gen_random_uuid(),
+      "name"                 VARCHAR     NOT NULL,
+      "display_name"         VARCHAR,
+      "field_type"           VARCHAR     NOT NULL,
+      "validation"           JSONB,
+      "entity_id"            UUID        NOT NULL,
+      "entity_type"          VARCHAR     NOT NULL,
+      "model_type"           VARCHAR     NOT NULL,
+      "description"          TEXT,
+      "required"             BOOLEAN     DEFAULT false,
+      "disabled"             BOOLEAN     DEFAULT false,
+      "default_value"        JSONB,
+      "block_editing_from_u_i" BOOLEAN    NOT NULL DEFAULT false,
+      "created_at"           TIMESTAMPTZ NOT NULL,
+      "updated_at"           TIMESTAMPTZ,
+      "deleted_at"           TIMESTAMPTZ,
+      PRIMARY KEY ("id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE UNIQUE INDEX IF NOT EXISTS "unique_name_model_type"
+    ON "custom_field_definitions" ("model_type", "entity_id", "name")
+  `);
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_field_values" (
+      "model_id"                    UUID        NOT NULL,
+      "custom_field_definition_id"  UUID        NOT NULL
+        REFERENCES "custom_field_definitions" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+      "value"                       JSONB,
+      "created_at"                  TIMESTAMPTZ NOT NULL,
+      "updated_at"                  TIMESTAMPTZ,
+      "deleted_at"                  TIMESTAMPTZ,
+      PRIMARY KEY ("model_id", "custom_field_definition_id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE INDEX IF NOT EXISTS "idx_custom_field_values_active_definition_id"
+    ON "custom_field_values" ("custom_field_definition_id")
+    WHERE "deleted_at" IS NULL
+  `);
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_validators" (
+      "id"          UUID        NOT NULL DEFAULT gen_random_uuid(),
+      "entity_id"   UUID        NOT NULL,
+      "entity_type" VARCHAR     NOT NULL,
+      "model_type"  VARCHAR     NOT NULL,
+      "schema"      JSONB       NOT NULL,
+      "disabled"    BOOLEAN     NOT NULL DEFAULT false,
+      "created_at"  TIMESTAMPTZ NOT NULL,
+      "updated_at"  TIMESTAMPTZ,
+      PRIMARY KEY ("id")
+    )
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query("DROP TABLE IF EXISTS \"custom_field_values\"");
+	await sequelize.query("DROP TABLE IF EXISTS \"custom_field_definitions\"");
+	await sequelize.query("DROP TABLE IF EXISTS \"custom_validators\"");
+};
+
+//#endregion
+exports.down = down;
+exports.up = up;

package/dist/migrations/001-create-core-tables.js

@@ -0,0 +1,68 @@
+//#region src/migrations/001-create-core-tables.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_field_definitions" (
+      "id"                   UUID        NOT NULL DEFAULT gen_random_uuid(),
+      "name"                 VARCHAR     NOT NULL,
+      "display_name"         VARCHAR,
+      "field_type"           VARCHAR     NOT NULL,
+      "validation"           JSONB,
+      "entity_id"            UUID        NOT NULL,
+      "entity_type"          VARCHAR     NOT NULL,
+      "model_type"           VARCHAR     NOT NULL,
+      "description"          TEXT,
+      "required"             BOOLEAN     DEFAULT false,
+      "disabled"             BOOLEAN     DEFAULT false,
+      "default_value"        JSONB,
+      "block_editing_from_u_i" BOOLEAN    NOT NULL DEFAULT false,
+      "created_at"           TIMESTAMPTZ NOT NULL,
+      "updated_at"           TIMESTAMPTZ,
+      "deleted_at"           TIMESTAMPTZ,
+      PRIMARY KEY ("id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE UNIQUE INDEX IF NOT EXISTS "unique_name_model_type"
+    ON "custom_field_definitions" ("model_type", "entity_id", "name")
+  `);
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_field_values" (
+      "model_id"                    UUID        NOT NULL,
+      "custom_field_definition_id"  UUID        NOT NULL
+        REFERENCES "custom_field_definitions" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+      "value"                       JSONB,
+      "created_at"                  TIMESTAMPTZ NOT NULL,
+      "updated_at"                  TIMESTAMPTZ,
+      "deleted_at"                  TIMESTAMPTZ,
+      PRIMARY KEY ("model_id", "custom_field_definition_id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE INDEX IF NOT EXISTS "idx_custom_field_values_active_definition_id"
+    ON "custom_field_values" ("custom_field_definition_id")
+    WHERE "deleted_at" IS NULL
+  `);
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_validators" (
+      "id"          UUID        NOT NULL DEFAULT gen_random_uuid(),
+      "entity_id"   UUID        NOT NULL,
+      "entity_type" VARCHAR     NOT NULL,
+      "model_type"  VARCHAR     NOT NULL,
+      "schema"      JSONB       NOT NULL,
+      "disabled"    BOOLEAN     NOT NULL DEFAULT false,
+      "created_at"  TIMESTAMPTZ NOT NULL,
+      "updated_at"  TIMESTAMPTZ,
+      PRIMARY KEY ("id")
+    )
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query("DROP TABLE IF EXISTS \"custom_field_values\"");
+	await sequelize.query("DROP TABLE IF EXISTS \"custom_field_definitions\"");
+	await sequelize.query("DROP TABLE IF EXISTS \"custom_validators\"");
+};
+
+//#endregion
+export { down, up };

package/dist/migrations/002-create-custom-field-entries.cjs

@@ -0,0 +1,27 @@
+
+//#region src/migrations/002-create-custom-field-entries.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_field_entries" (
+      "model_id"      UUID        NOT NULL,
+      "entity_id"     UUID        NOT NULL,
+      "custom_fields" JSONB       NOT NULL DEFAULT '{}',
+      "model_type"    VARCHAR     NOT NULL,
+      "created_at"    TIMESTAMPTZ NOT NULL,
+      "updated_at"    TIMESTAMPTZ,
+      PRIMARY KEY ("model_id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE INDEX IF NOT EXISTS "idx_cfe_custom_fields"
+    ON "custom_field_entries" USING gin ("custom_fields" jsonb_path_ops)
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	await queryInterface.sequelize.query("DROP TABLE IF EXISTS \"custom_field_entries\"");
+};
+
+//#endregion
+exports.down = down;
+exports.up = up;

package/dist/migrations/002-create-custom-field-entries.js

@@ -0,0 +1,25 @@
+//#region src/migrations/002-create-custom-field-entries.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_field_entries" (
+      "model_id"      UUID        NOT NULL,
+      "entity_id"     UUID        NOT NULL,
+      "custom_fields" JSONB       NOT NULL DEFAULT '{}',
+      "model_type"    VARCHAR     NOT NULL,
+      "created_at"    TIMESTAMPTZ NOT NULL,
+      "updated_at"    TIMESTAMPTZ,
+      PRIMARY KEY ("model_id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE INDEX IF NOT EXISTS "idx_cfe_custom_fields"
+    ON "custom_field_entries" USING gin ("custom_fields" jsonb_path_ops)
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	await queryInterface.sequelize.query("DROP TABLE IF EXISTS \"custom_field_entries\"");
+};
+
+//#endregion
+export { down, up };

package/dist/migrations/003-create-custom-field-model-type-map.cjs

@@ -0,0 +1,35 @@
+
+//#region src/migrations/003-create-custom-field-model-type-map.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_field_model_type_map" (
+      "id"                          UUID        NOT NULL DEFAULT gen_random_uuid(),
+      "model_type_id"               UUID        NOT NULL,
+      "custom_field_definition_id"  UUID        NOT NULL
+        REFERENCES "custom_field_definitions" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+      "created_at"                  TIMESTAMPTZ NOT NULL,
+      "updated_at"                  TIMESTAMPTZ NOT NULL,
+      PRIMARY KEY ("id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE UNIQUE INDEX IF NOT EXISTS "unique_model_type_custom_field"
+    ON "custom_field_model_type_map" ("model_type_id", "custom_field_definition_id")
+  `);
+	await sequelize.query(`
+    CREATE INDEX IF NOT EXISTS "idx_custom_field_model_type_map_definition_id"
+    ON "custom_field_model_type_map" ("custom_field_definition_id")
+  `);
+	await sequelize.query(`
+    CREATE INDEX IF NOT EXISTS "idx_custom_field_model_type_map_type_id"
+    ON "custom_field_model_type_map" ("model_type_id")
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	await queryInterface.sequelize.query("DROP TABLE IF EXISTS \"custom_field_model_type_map\"");
+};
+
+//#endregion
+exports.down = down;
+exports.up = up;

package/dist/migrations/003-create-custom-field-model-type-map.js

@@ -0,0 +1,33 @@
+//#region src/migrations/003-create-custom-field-model-type-map.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "custom_field_model_type_map" (
+      "id"                          UUID        NOT NULL DEFAULT gen_random_uuid(),
+      "model_type_id"               UUID        NOT NULL,
+      "custom_field_definition_id"  UUID        NOT NULL
+        REFERENCES "custom_field_definitions" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+      "created_at"                  TIMESTAMPTZ NOT NULL,
+      "updated_at"                  TIMESTAMPTZ NOT NULL,
+      PRIMARY KEY ("id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE UNIQUE INDEX IF NOT EXISTS "unique_model_type_custom_field"
+    ON "custom_field_model_type_map" ("model_type_id", "custom_field_definition_id")
+  `);
+	await sequelize.query(`
+    CREATE INDEX IF NOT EXISTS "idx_custom_field_model_type_map_definition_id"
+    ON "custom_field_model_type_map" ("custom_field_definition_id")
+  `);
+	await sequelize.query(`
+    CREATE INDEX IF NOT EXISTS "idx_custom_field_model_type_map_type_id"
+    ON "custom_field_model_type_map" ("model_type_id")
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	await queryInterface.sequelize.query("DROP TABLE IF EXISTS \"custom_field_model_type_map\"");
+};
+
+//#endregion
+export { down, up };

package/dist/migrations/004-create-field-policy-tables.cjs

@@ -0,0 +1,29 @@
+
+//#region src/migrations/004-create-field-policy-tables.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "field_policies" (
+      "id"          UUID        NOT NULL DEFAULT gen_random_uuid(),
+      "context_id"  UUID        NOT NULL,
+      "name"        VARCHAR     NOT NULL,
+      "fields"      JSONB       NOT NULL DEFAULT '[]',
+      "models"      JSONB       NOT NULL DEFAULT '[]',
+      "created_at"  TIMESTAMPTZ NOT NULL,
+      "updated_at"  TIMESTAMPTZ,
+      PRIMARY KEY ("id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE UNIQUE INDEX IF NOT EXISTS "unique_context_policy"
+    ON "field_policies" ("context_id", "name")
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query("DROP TABLE IF EXISTS \"field_policies\"");
+};
+
+//#endregion
+exports.down = down;
+exports.up = up;

package/dist/migrations/004-create-field-policy-tables.js

@@ -0,0 +1,27 @@
+//#region src/migrations/004-create-field-policy-tables.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    CREATE TABLE IF NOT EXISTS "field_policies" (
+      "id"          UUID        NOT NULL DEFAULT gen_random_uuid(),
+      "context_id"  UUID        NOT NULL,
+      "name"        VARCHAR     NOT NULL,
+      "fields"      JSONB       NOT NULL DEFAULT '[]',
+      "models"      JSONB       NOT NULL DEFAULT '[]',
+      "created_at"  TIMESTAMPTZ NOT NULL,
+      "updated_at"  TIMESTAMPTZ,
+      PRIMARY KEY ("id")
+    )
+  `);
+	await sequelize.query(`
+    CREATE UNIQUE INDEX IF NOT EXISTS "unique_context_policy"
+    ON "field_policies" ("context_id", "name")
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query("DROP TABLE IF EXISTS \"field_policies\"");
+};
+
+//#endregion
+export { down, up };

package/dist/migrations/005-add-entity-type-to-field-policies.cjs

@@ -0,0 +1,20 @@
+
+//#region src/migrations/005-add-entity-type-to-field-policies.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    ALTER TABLE "field_policies"
+    ADD COLUMN IF NOT EXISTS "entity_type" VARCHAR
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    ALTER TABLE "field_policies"
+    DROP COLUMN IF EXISTS "entity_type"
+  `);
+};
+
+//#endregion
+exports.down = down;
+exports.up = up;

package/dist/migrations/005-add-entity-type-to-field-policies.js

@@ -0,0 +1,18 @@
+//#region src/migrations/005-add-entity-type-to-field-policies.ts
+const up = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    ALTER TABLE "field_policies"
+    ADD COLUMN IF NOT EXISTS "entity_type" VARCHAR
+  `);
+};
+const down = async ({ context: queryInterface }) => {
+	const { sequelize } = queryInterface;
+	await sequelize.query(`
+    ALTER TABLE "field_policies"
+    DROP COLUMN IF EXISTS "entity_type"
+  `);
+};
+
+//#endregion
+export { down, up };

package/dist/migrations/index.cjs

@@ -0,0 +1,94 @@
+const require_index = require('../utils/logger/index.cjs');
+const require_001_create_core_tables = require('./001-create-core-tables.cjs');
+const require_002_create_custom_field_entries = require('./002-create-custom-field-entries.cjs');
+const require_003_create_custom_field_model_type_map = require('./003-create-custom-field-model-type-map.cjs');
+const require_004_create_field_policy_tables = require('./004-create-field-policy-tables.cjs');
+const require_005_add_entity_type_to_field_policies = require('./005-add-entity-type-to-field-policies.cjs');
+
+//#region src/migrations/index.ts
+const { Umzug, SequelizeStorage } = require("umzug");
+const buildMigrationList = (options) => {
+	const { useCustomFieldsEntries = false, useModelTypeMapping = false } = options;
+	return [
+		{
+			name: "001-create-core-tables",
+			up: require_001_create_core_tables.up,
+			down: require_001_create_core_tables.down
+		},
+		...useCustomFieldsEntries ? [{
+			name: "002-create-custom-field-entries",
+			up: require_002_create_custom_field_entries.up,
+			down: require_002_create_custom_field_entries.down
+		}] : [],
+		...useModelTypeMapping ? [{
+			name: "003-create-custom-field-model-type-map",
+			up: require_003_create_custom_field_model_type_map.up,
+			down: require_003_create_custom_field_model_type_map.down
+		}] : [],
+		{
+			name: "004-create-field-policy-tables",
+			up: require_004_create_field_policy_tables.up,
+			down: require_004_create_field_policy_tables.down
+		},
+		{
+			name: "005-add-entity-type-to-field-policies",
+			up: require_005_add_entity_type_to_field_policies.up,
+			down: require_005_add_entity_type_to_field_policies.down
+		}
+	];
+};
+const SADOT_MIGRATION_LOCK_ID = 839274628;
+/**
+* Runs sadot migrations via umzug. All migrations use IF NOT EXISTS / IF EXISTS,
+* so they are fully idempotent — safe to run against both fresh and existing
+* databases (including DBs previously managed by the legacy sync() path).
+*
+* A PostgreSQL advisory lock is acquired before running migrations so that when
+* multiple pods start concurrently only one of them executes the migrations.
+* The remaining pods block until the lock is released, then proceed — Umzug will
+* see the migrations have already been applied and skip them.
+*/
+const runSadotMigrations = async (sequelize, options = {}) => {
+	const queryInterface = sequelize.getQueryInterface();
+	const storage = new SequelizeStorage({
+		sequelize,
+		tableName: "sadot_migrations"
+	});
+	const migrator = new Umzug({
+		migrations: buildMigrationList(options),
+		context: queryInterface,
+		storage,
+		logger: {
+			info: (msg) => require_index.default.info(`[sadot] ${JSON.stringify(msg)}`),
+			warn: (msg) => require_index.default.warn(`[sadot] ${JSON.stringify(msg)}`),
+			error: (msg) => require_index.default.error(`[sadot] ${JSON.stringify(msg)}`),
+			debug: (msg) => require_index.default.debug(`[sadot] ${JSON.stringify(msg)}`)
+		}
+	});
+	const pending = await migrator.pending();
+	if (pending.length === 0) {
+		require_index.default.info("[sadot] no pending migrations, skipping");
+		return;
+	}
+	require_index.default.info("[sadot] pending migrations detected", { pending: pending.map((m) => m.name) });
+	if ((sequelize.options?.pool?.max ?? 5) < 2) {
+		require_index.default.info("[sadot] connection pool too small for advisory lock, running migrations directly");
+		await migrator.up();
+		return;
+	}
+	require_index.default.info("[sadot] acquiring advisory lock");
+	const transaction = await sequelize.transaction();
+	try {
+		await sequelize.query(`SELECT pg_advisory_lock(${SADOT_MIGRATION_LOCK_ID})`, { transaction });
+		require_index.default.info("[sadot] advisory lock acquired");
+		if ((await migrator.pending()).length > 0) await migrator.up();
+		else require_index.default.info("[sadot] migrations already applied by another instance, skipping");
+	} finally {
+		await sequelize.query(`SELECT pg_advisory_unlock(${SADOT_MIGRATION_LOCK_ID})`, { transaction });
+		await transaction.commit();
+		require_index.default.info("[sadot] advisory lock released");
+	}
+};
+
+//#endregion
+exports.runSadotMigrations = runSadotMigrations;