multivendor-wallet 0.0.1

package/dist/typeorm/index.js

@@ -0,0 +1,764 @@
+import { PrimaryGeneratedColumn, Column, BeforeInsert, BeforeUpdate, Entity } from 'typeorm';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function nowTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+}
+__name(nowTimestamp, "nowTimestamp");
+var _WalletAccountEntity = class _WalletAccountEntity {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "ownerType");
+    __publicField(this, "ownerId");
+    __publicField(this, "currency");
+    __publicField(this, "availableBalance");
+    __publicField(this, "heldBalance");
+    __publicField(this, "createdBy");
+    __publicField(this, "createdDate");
+    __publicField(this, "modifiedBy");
+    __publicField(this, "modifiedDate");
+  }
+  setCreated() {
+    this.createdDate = nowTimestamp();
+    this.modifiedDate = nowTimestamp();
+  }
+  setModified() {
+    this.modifiedDate = nowTimestamp();
+  }
+};
+__name(_WalletAccountEntity, "WalletAccountEntity");
+var WalletAccountEntity = _WalletAccountEntity;
+_ts_decorate([
+  PrimaryGeneratedColumn({
+    name: "id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "id", void 0);
+_ts_decorate([
+  Column({
+    name: "owner_type",
+    length: 32
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "ownerType", void 0);
+_ts_decorate([
+  Column({
+    name: "owner_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "ownerId", void 0);
+_ts_decorate([
+  Column({
+    name: "currency",
+    length: 8,
+    default: "INR"
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "currency", void 0);
+_ts_decorate([
+  Column({
+    name: "available_balance",
+    type: "bigint",
+    default: 0
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "availableBalance", void 0);
+_ts_decorate([
+  Column({
+    name: "held_balance",
+    type: "bigint",
+    default: 0
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "heldBalance", void 0);
+_ts_decorate([
+  Column({
+    name: "created_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "createdBy", void 0);
+_ts_decorate([
+  Column({
+    name: "created_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "createdDate", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletAccountEntity.prototype, "modifiedBy", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletAccountEntity.prototype, "modifiedDate", void 0);
+_ts_decorate([
+  BeforeInsert(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletAccountEntity.prototype, "setCreated", null);
+_ts_decorate([
+  BeforeUpdate(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletAccountEntity.prototype, "setModified", null);
+WalletAccountEntity = _ts_decorate([
+  Entity("wallet_account")
+], WalletAccountEntity);
+var _WalletLedgerEntryEntity = class _WalletLedgerEntryEntity {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "accountId");
+    __publicField(this, "entryType");
+    __publicField(this, "amount");
+    __publicField(this, "balanceAfterAvailable");
+    __publicField(this, "balanceAfterHeld");
+    __publicField(this, "idempotencyKey");
+    __publicField(this, "referenceType");
+    __publicField(this, "referenceId");
+    __publicField(this, "metadata");
+    __publicField(this, "createdBy");
+    __publicField(this, "createdDate");
+    __publicField(this, "modifiedBy");
+    __publicField(this, "modifiedDate");
+  }
+  setCreated() {
+    this.createdDate = nowTimestamp();
+    this.modifiedDate = nowTimestamp();
+  }
+};
+__name(_WalletLedgerEntryEntity, "WalletLedgerEntryEntity");
+var WalletLedgerEntryEntity = _WalletLedgerEntryEntity;
+_ts_decorate([
+  PrimaryGeneratedColumn({
+    name: "id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "id", void 0);
+_ts_decorate([
+  Column({
+    name: "account_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "accountId", void 0);
+_ts_decorate([
+  Column({
+    name: "entry_type",
+    length: 32
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "entryType", void 0);
+_ts_decorate([
+  Column({
+    name: "amount",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "amount", void 0);
+_ts_decorate([
+  Column({
+    name: "balance_after_available",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "balanceAfterAvailable", void 0);
+_ts_decorate([
+  Column({
+    name: "balance_after_held",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "balanceAfterHeld", void 0);
+_ts_decorate([
+  Column({
+    name: "idempotency_key",
+    length: 255,
+    unique: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "idempotencyKey", void 0);
+_ts_decorate([
+  Column({
+    name: "reference_type",
+    length: 64,
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "referenceType", void 0);
+_ts_decorate([
+  Column({
+    name: "reference_id",
+    length: 128,
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "referenceId", void 0);
+_ts_decorate([
+  Column({
+    name: "metadata",
+    type: "json",
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], WalletLedgerEntryEntity.prototype, "metadata", void 0);
+_ts_decorate([
+  Column({
+    name: "created_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "createdBy", void 0);
+_ts_decorate([
+  Column({
+    name: "created_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "createdDate", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletLedgerEntryEntity.prototype, "modifiedBy", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletLedgerEntryEntity.prototype, "modifiedDate", void 0);
+_ts_decorate([
+  BeforeInsert(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletLedgerEntryEntity.prototype, "setCreated", null);
+WalletLedgerEntryEntity = _ts_decorate([
+  Entity("wallet_ledger_entry")
+], WalletLedgerEntryEntity);
+var _WalletHoldEntity = class _WalletHoldEntity {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "sourceAccountId");
+    __publicField(this, "targetAccountId");
+    __publicField(this, "amount");
+    __publicField(this, "status");
+    __publicField(this, "referenceType");
+    __publicField(this, "referenceId");
+    __publicField(this, "idempotencyKey");
+    __publicField(this, "createdBy");
+    __publicField(this, "createdDate");
+    __publicField(this, "modifiedBy");
+    __publicField(this, "modifiedDate");
+  }
+  setCreated() {
+    this.createdDate = nowTimestamp();
+    this.modifiedDate = nowTimestamp();
+  }
+  setModified() {
+    this.modifiedDate = nowTimestamp();
+  }
+};
+__name(_WalletHoldEntity, "WalletHoldEntity");
+var WalletHoldEntity = _WalletHoldEntity;
+_ts_decorate([
+  PrimaryGeneratedColumn({
+    name: "id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "id", void 0);
+_ts_decorate([
+  Column({
+    name: "source_account_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "sourceAccountId", void 0);
+_ts_decorate([
+  Column({
+    name: "target_account_id"
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "targetAccountId", void 0);
+_ts_decorate([
+  Column({
+    name: "amount",
+    type: "bigint"
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "amount", void 0);
+_ts_decorate([
+  Column({
+    name: "status",
+    length: 16,
+    default: "active"
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "status", void 0);
+_ts_decorate([
+  Column({
+    name: "reference_type",
+    length: 64
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "referenceType", void 0);
+_ts_decorate([
+  Column({
+    name: "reference_id",
+    length: 128
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "referenceId", void 0);
+_ts_decorate([
+  Column({
+    name: "idempotency_key",
+    length: 255
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "idempotencyKey", void 0);
+_ts_decorate([
+  Column({
+    name: "created_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "createdBy", void 0);
+_ts_decorate([
+  Column({
+    name: "created_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "createdDate", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_by",
+    nullable: true
+  }),
+  _ts_metadata("design:type", Number)
+], WalletHoldEntity.prototype, "modifiedBy", void 0);
+_ts_decorate([
+  Column({
+    name: "modified_date",
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], WalletHoldEntity.prototype, "modifiedDate", void 0);
+_ts_decorate([
+  BeforeInsert(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletHoldEntity.prototype, "setCreated", null);
+_ts_decorate([
+  BeforeUpdate(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], WalletHoldEntity.prototype, "setModified", null);
+WalletHoldEntity = _ts_decorate([
+  Entity("wallet_hold")
+], WalletHoldEntity);
+
+// src/errors.ts
+var _WalletError = class _WalletError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WalletError";
+  }
+};
+__name(_WalletError, "WalletError");
+var WalletError = _WalletError;
+var _DuplicateOperationError = class _DuplicateOperationError extends WalletError {
+  constructor(message, existingEntry) {
+    super(message);
+    __publicField(this, "existingEntry");
+    this.name = "DuplicateOperationError";
+    this.existingEntry = existingEntry;
+  }
+};
+__name(_DuplicateOperationError, "DuplicateOperationError");
+var DuplicateOperationError = _DuplicateOperationError;
+
+// src/typeorm/store.ts
+function toNumber(value) {
+  if (value == null) {
+    return 0;
+  }
+  return Number(value);
+}
+__name(toNumber, "toNumber");
+function toLedgerAccount(row) {
+  return {
+    id: row.id,
+    ownerType: row.ownerType,
+    ownerId: row.ownerId,
+    currency: row.currency,
+    availableBalance: toNumber(row.availableBalance),
+    heldBalance: toNumber(row.heldBalance)
+  };
+}
+__name(toLedgerAccount, "toLedgerAccount");
+function toLedgerHold(row) {
+  return {
+    id: row.id,
+    sourceAccountId: row.sourceAccountId,
+    targetAccountId: row.targetAccountId,
+    amount: toNumber(row.amount),
+    status: row.status,
+    referenceType: row.referenceType,
+    referenceId: row.referenceId,
+    idempotencyKey: row.idempotencyKey,
+    createdAt: new Date(row.createdDate)
+  };
+}
+__name(toLedgerHold, "toLedgerHold");
+function toLedgerEntry(row) {
+  return {
+    id: row.id,
+    accountId: row.accountId,
+    entryType: row.entryType,
+    amount: toNumber(row.amount),
+    balanceAfterAvailable: toNumber(row.balanceAfterAvailable),
+    balanceAfterHeld: toNumber(row.balanceAfterHeld),
+    idempotencyKey: row.idempotencyKey,
+    referenceType: row.referenceType,
+    referenceId: row.referenceId,
+    metadata: row.metadata,
+    createdAt: new Date(row.createdDate)
+  };
+}
+__name(toLedgerEntry, "toLedgerEntry");
+function isEntityManager(value) {
+  return value != null && typeof value === "object" && typeof value.getRepository === "function";
+}
+__name(isEntityManager, "isEntityManager");
+var _a;
+var TypeOrmWalletStoreTx = (_a = class {
+  constructor(em) {
+    __publicField(this, "em");
+    this.em = em;
+  }
+  async getOrCreateAccount(type, ownerId, currency) {
+    const repo = this.em.getRepository(WalletAccountEntity);
+    let row = await repo.findOne({
+      where: {
+        ownerType: type,
+        ownerId,
+        currency
+      }
+    });
+    if (!row) {
+      row = repo.create({
+        ownerType: type,
+        ownerId,
+        currency,
+        availableBalance: "0",
+        heldBalance: "0"
+      });
+      row = await repo.save(row);
+    }
+    return toLedgerAccount(row);
+  }
+  async lockAccount(accountId) {
+    const row = await this.em.getRepository(WalletAccountEntity).createQueryBuilder("wa").setLock("pessimistic_write").where("wa.id = :id", {
+      id: accountId
+    }).getOne();
+    if (!row) {
+      throw new Error(`Wallet account ${accountId} not found`);
+    }
+    return toLedgerAccount(row);
+  }
+  async getAccountById(accountId) {
+    const row = await this.em.getRepository(WalletAccountEntity).findOne({
+      where: {
+        id: accountId
+      }
+    });
+    return row ? toLedgerAccount(row) : null;
+  }
+  async appendLedgerEntry(entry) {
+    const existing = await this.findLedgerByIdempotencyKey(entry.idempotencyKey);
+    if (existing) {
+      return existing;
+    }
+    const repo = this.em.getRepository(WalletLedgerEntryEntity);
+    try {
+      const row = await repo.save(repo.create({
+        accountId: entry.accountId,
+        entryType: entry.entryType,
+        amount: String(entry.amount),
+        balanceAfterAvailable: String(entry.balanceAfterAvailable),
+        balanceAfterHeld: String(entry.balanceAfterHeld),
+        idempotencyKey: entry.idempotencyKey,
+        referenceType: entry.referenceType,
+        referenceId: entry.referenceId,
+        metadata: entry.metadata
+      }));
+      return toLedgerEntry(row);
+    } catch (error) {
+      const err = error;
+      const code = err?.code || err?.errno;
+      if (code === "ER_DUP_ENTRY" || code === 1062) {
+        const dup = await this.findLedgerByIdempotencyKey(entry.idempotencyKey);
+        if (dup) {
+          return dup;
+        }
+        throw new DuplicateOperationError("Duplicate idempotency key", null);
+      }
+      throw error;
+    }
+  }
+  async updateBalances(accountId, deltas) {
+    const row = await this.em.getRepository(WalletAccountEntity).createQueryBuilder("wa").setLock("pessimistic_write").where("wa.id = :id", {
+      id: accountId
+    }).getOne();
+    if (!row) {
+      throw new Error(`Wallet account ${accountId} not found`);
+    }
+    const available = toNumber(row.availableBalance) + (deltas.availableDelta ?? 0);
+    const held = toNumber(row.heldBalance) + (deltas.heldDelta ?? 0);
+    if (available < 0 || held < 0) {
+      throw new Error("Balance cannot be negative");
+    }
+    row.availableBalance = String(available);
+    row.heldBalance = String(held);
+    const saved = await this.em.getRepository(WalletAccountEntity).save(row);
+    return toLedgerAccount(saved);
+  }
+  async findHoldByReference(ref) {
+    const row = await this.em.getRepository(WalletHoldEntity).findOne({
+      where: {
+        referenceType: ref.referenceType,
+        referenceId: ref.referenceId
+      },
+      order: {
+        id: "DESC"
+      }
+    });
+    return row ? toLedgerHold(row) : null;
+  }
+  async upsertHold(hold) {
+    const repo = this.em.getRepository(WalletHoldEntity);
+    let row;
+    if (hold.id != null) {
+      row = await repo.findOne({
+        where: {
+          id: hold.id
+        }
+      });
+    }
+    if (!row) {
+      row = await repo.findOne({
+        where: {
+          referenceType: hold.referenceType,
+          referenceId: hold.referenceId
+        }
+      });
+    }
+    if (!row) {
+      row = repo.create({
+        sourceAccountId: hold.sourceAccountId,
+        targetAccountId: hold.targetAccountId,
+        amount: String(hold.amount),
+        status: hold.status,
+        referenceType: hold.referenceType,
+        referenceId: hold.referenceId,
+        idempotencyKey: hold.idempotencyKey
+      });
+    } else {
+      row.sourceAccountId = hold.sourceAccountId;
+      row.targetAccountId = hold.targetAccountId;
+      row.amount = String(hold.amount);
+      row.status = hold.status;
+      row.idempotencyKey = hold.idempotencyKey;
+    }
+    const saved = await repo.save(row);
+    return toLedgerHold(saved);
+  }
+  async findLedgerByIdempotencyKey(key) {
+    const row = await this.em.getRepository(WalletLedgerEntryEntity).findOne({
+      where: {
+        idempotencyKey: key
+      }
+    });
+    return row ? toLedgerEntry(row) : null;
+  }
+  async listLedgerEntries(accountId, limit, offset) {
+    const rows = await this.em.getRepository(WalletLedgerEntryEntity).find({
+      where: {
+        accountId
+      },
+      order: {
+        id: "DESC"
+      },
+      take: limit,
+      skip: offset
+    });
+    return rows.map(toLedgerEntry);
+  }
+}, __name(_a, "TypeOrmWalletStoreTx"), _a);
+var _TypeOrmWalletStore = class _TypeOrmWalletStore {
+  constructor(connection) {
+    __publicField(this, "connection");
+    this.connection = connection;
+  }
+  async runInTransaction(fn, ctx) {
+    if (isEntityManager(ctx?.nativeTx)) {
+      return fn(new TypeOrmWalletStoreTx(ctx.nativeTx));
+    }
+    return this.connection.manager.transaction(async (em) => fn(new TypeOrmWalletStoreTx(em)));
+  }
+};
+__name(_TypeOrmWalletStore, "TypeOrmWalletStore");
+var TypeOrmWalletStore = _TypeOrmWalletStore;
+
+// src/typeorm/migrations/CreateWalletTables.ts
+async function indexExists(queryRunner, tableName, indexName) {
+  const rows = await queryRunner.query(`SELECT COUNT(1) AS c
+     FROM information_schema.statistics
+     WHERE table_schema = DATABASE()
+       AND table_name = ?
+       AND index_name = ?`, [
+    tableName,
+    indexName
+  ]);
+  return Number(rows[0]?.c ?? 0) > 0;
+}
+__name(indexExists, "indexExists");
+var _CreateWalletTables1790000000000 = class _CreateWalletTables1790000000000 {
+  async up(queryRunner) {
+    if (!await queryRunner.hasTable("wallet_account")) {
+      await queryRunner.query(`
+        CREATE TABLE \`wallet_account\` (
+          \`id\` int NOT NULL AUTO_INCREMENT,
+          \`owner_type\` varchar(32) NOT NULL,
+          \`owner_id\` int NOT NULL,
+          \`currency\` varchar(8) NOT NULL DEFAULT 'INR',
+          \`available_balance\` bigint NOT NULL DEFAULT 0,
+          \`held_balance\` bigint NOT NULL DEFAULT 0,
+          \`created_by\` int NULL,
+          \`created_date\` datetime NULL,
+          \`modified_by\` int NULL,
+          \`modified_date\` datetime NULL,
+          PRIMARY KEY (\`id\`)
+        ) ENGINE=InnoDB
+      `);
+    }
+    if (!await indexExists(queryRunner, "wallet_account", "IDX_wallet_account_owner_currency")) {
+      await queryRunner.query(`
+        CREATE UNIQUE INDEX \`IDX_wallet_account_owner_currency\`
+        ON \`wallet_account\` (\`owner_type\`, \`owner_id\`, \`currency\`)
+      `);
+    }
+    if (!await queryRunner.hasTable("wallet_ledger_entry")) {
+      await queryRunner.query(`
+        CREATE TABLE \`wallet_ledger_entry\` (
+          \`id\` int NOT NULL AUTO_INCREMENT,
+          \`account_id\` int NOT NULL,
+          \`entry_type\` varchar(32) NOT NULL,
+          \`amount\` bigint NOT NULL,
+          \`balance_after_available\` bigint NOT NULL,
+          \`balance_after_held\` bigint NOT NULL,
+          \`idempotency_key\` varchar(255) NOT NULL,
+          \`reference_type\` varchar(64) NULL,
+          \`reference_id\` varchar(128) NULL,
+          \`metadata\` json NULL,
+          \`created_by\` int NULL,
+          \`created_date\` datetime NULL,
+          \`modified_by\` int NULL,
+          \`modified_date\` datetime NULL,
+          PRIMARY KEY (\`id\`),
+          UNIQUE INDEX \`UQ_wallet_ledger_idempotency_key\` (\`idempotency_key\`)
+        ) ENGINE=InnoDB
+      `);
+    }
+    if (!await indexExists(queryRunner, "wallet_ledger_entry", "IDX_wallet_ledger_account_id")) {
+      await queryRunner.query(`
+        CREATE INDEX \`IDX_wallet_ledger_account_id\`
+        ON \`wallet_ledger_entry\` (\`account_id\`)
+      `);
+    }
+    if (!await queryRunner.hasTable("wallet_hold")) {
+      await queryRunner.query(`
+        CREATE TABLE \`wallet_hold\` (
+          \`id\` int NOT NULL AUTO_INCREMENT,
+          \`source_account_id\` int NOT NULL,
+          \`target_account_id\` int NOT NULL,
+          \`amount\` bigint NOT NULL,
+          \`status\` varchar(16) NOT NULL DEFAULT 'active',
+          \`reference_type\` varchar(64) NOT NULL,
+          \`reference_id\` varchar(128) NOT NULL,
+          \`idempotency_key\` varchar(255) NOT NULL,
+          \`created_by\` int NULL,
+          \`created_date\` datetime NULL,
+          \`modified_by\` int NULL,
+          \`modified_date\` datetime NULL,
+          PRIMARY KEY (\`id\`)
+        ) ENGINE=InnoDB
+      `);
+    }
+    if (!await indexExists(queryRunner, "wallet_hold", "IDX_wallet_hold_reference")) {
+      await queryRunner.query(`
+        CREATE INDEX \`IDX_wallet_hold_reference\`
+        ON \`wallet_hold\` (\`reference_type\`, \`reference_id\`)
+      `);
+    }
+  }
+  async down(queryRunner) {
+    if (await queryRunner.hasTable("wallet_hold")) {
+      await queryRunner.query("DROP TABLE `wallet_hold`");
+    }
+    if (await queryRunner.hasTable("wallet_ledger_entry")) {
+      await queryRunner.query("DROP TABLE `wallet_ledger_entry`");
+    }
+    if (await queryRunner.hasTable("wallet_account")) {
+      await queryRunner.query("DROP TABLE `wallet_account`");
+    }
+  }
+};
+__name(_CreateWalletTables1790000000000, "CreateWalletTables1790000000000");
+var CreateWalletTables1790000000000 = _CreateWalletTables1790000000000;
+
+// src/typeorm/metadata.ts
+function getWalletOrmMetadata() {
+  return {
+    entities: [
+      WalletAccountEntity,
+      WalletLedgerEntryEntity,
+      WalletHoldEntity
+    ],
+    migrations: [
+      CreateWalletTables1790000000000
+    ]
+  };
+}
+__name(getWalletOrmMetadata, "getWalletOrmMetadata");
+
+export { CreateWalletTables1790000000000, TypeOrmWalletStore, WalletAccountEntity, WalletHoldEntity, WalletLedgerEntryEntity, getWalletOrmMetadata };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map