@nest-batch/typeorm 0.2.0

package/dist/src/transaction/typeorm-transaction-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/transaction/typeorm-transaction-manager.ts"],"sourcesContent":["import { Inject, Injectable } from '@nestjs/common';\nimport { randomUUID } from 'node:crypto';\nimport { DataSource, EntityManager } from 'typeorm';\nimport {\n  TransactionManager,\n  type TransactionContext,\n} from '@nest-batch/core';\nimport { TypeOrmDriverProvider } from '../typeorm.driver-provider';\n\nexport interface TypeOrmTransactionContext extends TransactionContext {\n  readonly isActive: true;\n  readonly id: string;\n  readonly entityManager: EntityManager;\n}\n\n/**\n * TransactionManager bound to TypeORM 1.0.0's `DataSource.transaction()`.\n *\n * Wraps the user callback in a real DB transaction. On success the\n * transaction commits; if `fn(ctx)` throws, the transaction rolls back.\n *\n * The transactional EM is the one passed to the callback —\n * consumers should use that `entityManager` (not any\n * globally-injected one) so that all reads and writes are part of\n * the same transaction.\n */\n@Injectable()\nexport class TypeOrmTransactionManager extends TransactionManager {\n  constructor(\n    @Inject(TypeOrmDriverProvider) private readonly dataSource: DataSource,\n  ) {\n    super();\n  }\n\n  async withTransaction<T>(\n    fn: (ctx: TypeOrmTransactionContext) => Promise<T>,\n  ): Promise<T> {\n    return this.dataSource.transaction(async (txEm) => {\n      const ctx: TypeOrmTransactionContext = {\n        isActive: true,\n        id: randomUUID(),\n        entityManager: txEm,\n      };\n      return fn(ctx);\n    });\n  }\n}\n"],"names":["TypeOrmTransactionManager","TransactionManager","dataSource","withTransaction","fn","transaction","txEm","ctx","isActive","id","randomUUID","entityManager"],"mappings":";;;;+BA2BaA;;;eAAAA;;;wBA3BsB;4BACR;yBACe;sBAInC;uCAC+B;;;;;;;;;;;;;;;AAoB/B,IAAA,AAAMA,4BAAN,MAAMA,kCAAkCC,wBAAkB;;IAC/D,YACE,AAAgDC,UAAsB,CACtE;QACA,KAAK,SAF2CA,aAAAA;IAGlD;IAEA,MAAMC,gBACJC,EAAkD,EACtC;QACZ,OAAO,IAAI,CAACF,UAAU,CAACG,WAAW,CAAC,OAAOC;YACxC,MAAMC,MAAiC;gBACrCC,UAAU;gBACVC,IAAIC,IAAAA,sBAAU;gBACdC,eAAeL;YACjB;YACA,OAAOF,GAAGG;QACZ;IACF;AACF"}

package/dist/src/typeorm.driver-provider.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `TypeOrmDriverProvider` — the abstract injection token the
+ * `@nest-batch/postgresql` (and future `@nest-batch/mysql`) driver
+ * sibling packages bind to the concrete `DataSource` for the chosen
+ * database.
+ *
+ * This package (`@nest-batch/typeorm`) is **driver-agnostic**: it
+ * does not import `@nestjs/typeorm` (which carries the Postgres
+ * driver) or any MySQL-specific `@nestjs/typeorm` companion. Instead,
+ * it exports the `TypeOrmDriverProvider` symbol as a `Provider`
+ * token; the driver sibling package binds the token to a concrete
+ * `DataSource` in its own `forRoot()` factory.
+ *
+ * The `TypeOrmJobRepository` / `TypeOrmTransactionManager` classes
+ * inject the token via the standard `@Inject(TypeOrmDriverProvider)`
+ * decorator and cast the resolved value to the host-owned
+ * `DataSource` shape. This mirrors the
+ * `@nestjs/typeorm` pattern of "host owns the connection, adapter
+ * owns the repository".
+ */
+export declare const TypeOrmDriverProvider: symbol;
+//# sourceMappingURL=typeorm.driver-provider.d.ts.map

package/dist/src/typeorm.driver-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm.driver-provider.d.ts","sourceRoot":"","sources":["../../src/typeorm.driver-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAEnC,CAAC"}

package/dist/src/typeorm.driver-provider.js

@@ -0,0 +1,32 @@
+/**
+ * `TypeOrmDriverProvider` — the abstract injection token the
+ * `@nest-batch/postgresql` (and future `@nest-batch/mysql`) driver
+ * sibling packages bind to the concrete `DataSource` for the chosen
+ * database.
+ *
+ * This package (`@nest-batch/typeorm`) is **driver-agnostic**: it
+ * does not import `@nestjs/typeorm` (which carries the Postgres
+ * driver) or any MySQL-specific `@nestjs/typeorm` companion. Instead,
+ * it exports the `TypeOrmDriverProvider` symbol as a `Provider`
+ * token; the driver sibling package binds the token to a concrete
+ * `DataSource` in its own `forRoot()` factory.
+ *
+ * The `TypeOrmJobRepository` / `TypeOrmTransactionManager` classes
+ * inject the token via the standard `@Inject(TypeOrmDriverProvider)`
+ * decorator and cast the resolved value to the host-owned
+ * `DataSource` shape. This mirrors the
+ * `@nestjs/typeorm` pattern of "host owns the connection, adapter
+ * owns the repository".
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TypeOrmDriverProvider", {
+    enumerable: true,
+    get: function() {
+        return TypeOrmDriverProvider;
+    }
+});
+const TypeOrmDriverProvider = Symbol.for('@nest-batch/typeorm/TypeOrmDriverProvider');
+
+//# sourceMappingURL=typeorm.driver-provider.js.map

package/dist/src/typeorm.driver-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/typeorm.driver-provider.ts"],"sourcesContent":["/**\n * `TypeOrmDriverProvider` — the abstract injection token the\n * `@nest-batch/postgresql` (and future `@nest-batch/mysql`) driver\n * sibling packages bind to the concrete `DataSource` for the chosen\n * database.\n *\n * This package (`@nest-batch/typeorm`) is **driver-agnostic**: it\n * does not import `@nestjs/typeorm` (which carries the Postgres\n * driver) or any MySQL-specific `@nestjs/typeorm` companion. Instead,\n * it exports the `TypeOrmDriverProvider` symbol as a `Provider`\n * token; the driver sibling package binds the token to a concrete\n * `DataSource` in its own `forRoot()` factory.\n *\n * The `TypeOrmJobRepository` / `TypeOrmTransactionManager` classes\n * inject the token via the standard `@Inject(TypeOrmDriverProvider)`\n * decorator and cast the resolved value to the host-owned\n * `DataSource` shape. This mirrors the\n * `@nestjs/typeorm` pattern of \"host owns the connection, adapter\n * owns the repository\".\n */\nexport const TypeOrmDriverProvider: symbol = Symbol.for(\n  '@nest-batch/typeorm/TypeOrmDriverProvider',\n);\n"],"names":["TypeOrmDriverProvider","Symbol","for"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;CAmBC;;;;+BACYA;;;eAAAA;;;AAAN,MAAMA,wBAAgCC,OAAOC,GAAG,CACrD"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@nest-batch/typeorm",
+  "version": "0.2.0",
+  "description": "TypeORM 1.0.0 adapter SLOT for @nest-batch/core — JobRepository and TransactionManager interface shape, paired with @nest-batch/postgresql (Postgres driver) or @nest-batch/mysql (MySQL driver).",
+  "license": "MIT",
+  "author": "easdkr",
+  "homepage": "https://github.com/easdkr/nest-batch/tree/main/packages/typeorm#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/easdkr/nest-batch.git",
+    "directory": "packages/typeorm"
+  },
+  "bugs": {
+    "url": "https://github.com/easdkr/nest-batch/issues"
+  },
+  "keywords": [
+    "nestjs",
+    "batch",
+    "typeorm",
+    "job-repository",
+    "persistence"
+  ],
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "dist/src",
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10 || ^11",
+    "typeorm": "^1.0.0",
+    "@nest-batch/core": "^0.2.0"
+  },
+  "peerDependenciesMeta": {
+    "typeorm": {
+      "optional": false
+    },
+    "@nest-batch/core": {
+      "optional": false
+    },
+    "@nestjs/common": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@swc/cli": "^0.7.0",
+    "@swc/core": "^1.10.7",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.0.0",
+    "better-sqlite3": "^12.0.0",
+    "reflect-metadata": "^0.2.2",
+    "typeorm": "^1.0.0",
+    "typescript": "^5.5.0",
+    "unplugin-swc": "^1.5.0",
+    "vitest": "^2.0.0",
+    "@nest-batch/core": "0.2.0"
+  },
+  "scripts": {
+    "build": "swc src -d dist --config-file ../../.swcrc && tsc --emitDeclarationOnly -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/adapters/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Public surface for the `adapters/` package directory.
+ *
+ * Re-exports the `TypeOrmAdapter` factory so consumers can
+ * import it via `@nest-batch/typeorm` (the root barrel pulls
+ * this file in) without having to know the internal directory
+ * layout.
+ *
+ * The factory is the recommended entry point for wiring
+ * TypeORM 1.0.0 as the `@nest-batch/core` persistence backend.
+ * The legacy `NestBatchTypeOrmModule` (mentioned in
+ * `packages/typeorm/README.md`) was never actually implemented
+ * in code; this adapter is the canonical replacement and the
+ * shape that lines up with the new factory-pattern API
+ * (`NestBatchModule.forRoot({ adapters: { persistence, ... } })`).
+ */
+export * from './typeorm.adapter';

package/src/adapters/typeorm.adapter.ts

@@ -0,0 +1,82 @@
+import { Module } from '@nestjs/common';
+
+import {
+  JOB_REPOSITORY_TOKEN,
+  TRANSACTION_MANAGER_TOKEN,
+  type BatchAdapter,
+} from '@nest-batch/core';
+
+import { TypeOrmJobRepository } from '../repository/typeorm-job-repository';
+import { TypeOrmTransactionManager } from '../transaction/typeorm-transaction-manager';
+
+/**
+ * Empty Nest module class that owns the TypeORM batch adapter
+ * providers.
+ *
+ * The class has no body on purpose: it is purely a `DynamicModule`
+ * carrier for the `forRoot()` factory below. Nest's module system
+ * requires *some* class to identify the module — the empty class
+ * is the minimum possible surface and keeps the runtime allocation
+ * at one class (no decorators, no lifecycle hooks, no metadata).
+ */
+@Module({})
+export class TypeOrmBatchModule {}
+
+/**
+ * `TypeOrmAdapter` — the TypeORM 1.0.0 persistence adapter for
+ * `@nest-batch/core`.
+ *
+ * It owns the `JOB_REPOSITORY_TOKEN` and `TRANSACTION_MANAGER_TOKEN`
+ * bindings to the TypeORM-backed `TypeOrmJobRepository` /
+ * `TypeOrmTransactionManager` implementations. This adapter does
+ * not call `TypeOrmModule.forRoot()` — the host must call it in
+ * `AppModule.imports` (and register the six batch meta entities
+ * on the resulting `DataSource`).
+ */
+export class TypeOrmAdapter {
+  /**
+   * Build the `BatchAdapter` value the new factory-pattern
+   * `NestBatchModule.forRoot({ adapters: { persistence, ... } })`
+   * expects.
+   *
+   * No options are accepted on purpose — the host already owns
+   * the `TypeOrmModule.forRoot(...)` call. The adapter only needs
+   * to declare its own provider / export / `globalProviders`
+   * surface; the `DataSource` itself is the host's responsibility.
+   *
+   * @returns A `BatchAdapter` whose `module` is a `global: true`
+   *   `DynamicModule` exposing `JOB_REPOSITORY_TOKEN` and
+   *   `TRANSACTION_MANAGER_TOKEN` to the host application.
+   */
+  static forRoot(): BatchAdapter {
+    return {
+      name: 'typeorm',
+      module: {
+        module: TypeOrmBatchModule,
+        global: true,
+        providers: [
+          TypeOrmJobRepository,
+          TypeOrmTransactionManager,
+          {
+            provide: JOB_REPOSITORY_TOKEN,
+            useExisting: TypeOrmJobRepository,
+          },
+          {
+            provide: TRANSACTION_MANAGER_TOKEN,
+            useExisting: TypeOrmTransactionManager,
+          },
+        ],
+        exports: [JOB_REPOSITORY_TOKEN, TRANSACTION_MANAGER_TOKEN],
+      },
+      globalProviders: [
+        { provide: JOB_REPOSITORY_TOKEN, useClass: TypeOrmJobRepository },
+        {
+          provide: TRANSACTION_MANAGER_TOKEN,
+          useClass: TypeOrmTransactionManager,
+        },
+      ],
+    };
+  }
+}
+
+

package/src/entities/index.ts

@@ -0,0 +1 @@
+export * from './job-meta.entities';

package/src/entities/job-meta.entities.ts

@@ -0,0 +1,184 @@
+import { Entity, PrimaryColumn, Column, Index } from 'typeorm';
+
+/**
+ * `batch_job_instance` metadata row.
+ *
+ * One row per logical job instance. Uniqueness is enforced on
+ * (jobName, jobKey) so that the same canonical key resolves to the
+ * same instance across restarts. The composite unique index is
+ * declared on the entity and is also reified in the bundled
+ * migration under the same name.
+ */
+@Entity('batch_job_instance')
+@Index('batch_job_instance_job_name_job_key_unique', ['jobName', 'jobKey'], { unique: true })
+export class JobInstanceEntity {
+  @PrimaryColumn({ type: 'varchar', length: 255 })
+  id!: string;
+
+  @Column({ name: 'job_name', type: 'varchar', length: 255 })
+  jobName!: string;
+
+  @Column({ name: 'job_key', type: 'varchar', length: 255 })
+  jobKey!: string;
+
+  @Column({
+    name: 'created_at',
+    // `datetime` is portable across PostgreSQL and SQLite (the test
+    // driver). The bundled migration uses timestamptz on
+    // PostgreSQL by hand; SQLite loses the timezone qualifier,
+    // which is acceptable for a creation-time stamp that is never
+    // compared with sub-second precision in queries.
+    type: 'datetime',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  createdAt: Date = new Date();
+}
+
+/**
+ * `batch_job_execution` metadata row.
+ *
+ * One row per job run. `status` is the stringified JobStatus enum
+ * (kept as a plain varchar — TypeORM enum support varies across
+ * drivers and v1.0.0 dropped a few columns we don't need). The
+ * `jobInstanceId` column is indexed because every contract lookup
+ * ("is this instance running?") scans by it.
+ */
+@Entity('batch_job_execution')
+@Index('batch_job_execution_job_instance_id_index', ['jobInstanceId'])
+export class JobExecutionEntity {
+  @PrimaryColumn({ type: 'varchar', length: 255 })
+  id!: string;
+
+  @Column({ name: 'job_instance_id', type: 'varchar', length: 255 })
+  jobInstanceId!: string;
+
+  @Column({ type: 'varchar', length: 20 })
+  status!: string;
+
+  @Column({ name: 'start_time', type: 'datetime', nullable: true })
+  startTime: Date | null = null;
+
+  @Column({ name: 'end_time', type: 'datetime', nullable: true })
+  endTime: Date | null = null;
+
+  @Column({ name: 'exit_code', type: 'varchar', length: 255, default: '' })
+  exitCode!: string;
+
+  @Column({ name: 'exit_message', type: 'text', default: '' })
+  exitMessage!: string;
+
+  /**
+   * JSON-serialized `JobParameters` snapshot. Stored as `text` (not
+   * native `jsonb`) so the adapter works uniformly across SQLite (used
+   * in unit tests) and PostgreSQL/MySQL — the column is always a
+   * serialized payload, never queried by the ORM.
+   */
+  @Column({ name: 'params', type: 'text', default: '{}' })
+  params!: string;
+}
+
+/**
+ * `batch_step_execution` metadata row.
+ *
+ * One row per step run. Counters default to 0 so the entity can
+ * be persisted immediately upon creation, before any items are
+ * processed. `createdAt` is stamped on insert and used by
+ * `findLatestStepExecution` to resolve the most recently created
+ * step for a given `(jobExecutionId, stepName)` pair — a v4 UUID
+ * primary key does not preserve insertion order, so an explicit
+ * monotonic column is required.
+ */
+@Entity('batch_step_execution')
+@Index('batch_step_execution_job_execution_id_index', ['jobExecutionId'])
+export class StepExecutionEntity {
+  @PrimaryColumn({ type: 'varchar', length: 255 })
+  id!: string;
+
+  @Column({ name: 'job_execution_id', type: 'varchar', length: 255 })
+  jobExecutionId!: string;
+
+  @Column({ name: 'step_name', type: 'varchar', length: 255 })
+  stepName!: string;
+
+  @Column({ type: 'varchar', length: 20 })
+  status!: string;
+
+  @Column({ name: 'read_count', type: 'int', default: 0 })
+  readCount!: number;
+
+  @Column({ name: 'write_count', type: 'int', default: 0 })
+  writeCount!: number;
+
+  @Column({ name: 'skip_count', type: 'int', default: 0 })
+  skipCount!: number;
+
+  @Column({ name: 'rollback_count', type: 'int', default: 0 })
+  rollbackCount!: number;
+
+  @Column({ name: 'commit_count', type: 'int', default: 0 })
+  commitCount!: number;
+
+  @Column({ name: 'exit_code', type: 'varchar', length: 255, default: '' })
+  exitCode!: string;
+
+  @Column({ name: 'exit_message', type: 'text', default: '' })
+  exitMessage!: string;
+
+  @Column({
+    name: 'created_at',
+    type: 'datetime',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  createdAt: Date = new Date();
+}
+
+/**
+ * `batch_job_execution_context` metadata row.
+ *
+ * `data` is a JSON-serialized ExecutionContext payload. `version`
+ * guards against lost updates during concurrent writers.
+ */
+@Entity('batch_job_execution_context')
+export class JobExecutionContextEntity {
+  @PrimaryColumn({ name: 'job_execution_id', type: 'varchar', length: 255 })
+  jobExecutionId!: string;
+
+  @Column({ type: 'text' })
+  data!: string;
+
+  @Column({ type: 'int', default: 0 })
+  version!: number;
+}
+
+/**
+ * `batch_step_execution_context` metadata row.
+ *
+ * Mirrors the job-level context table but scoped to a single
+ * step execution. There is intentionally no params sibling table
+ * for steps — step parameters are derivable from the parent job
+ * execution params + the step execution context.
+ */
+@Entity('batch_step_execution_context')
+export class StepExecutionContextEntity {
+  @PrimaryColumn({ name: 'step_execution_id', type: 'varchar', length: 255 })
+  stepExecutionId!: string;
+
+  @Column({ type: 'text' })
+  data!: string;
+
+  @Column({ type: 'int', default: 0 })
+  version!: number;
+}
+
+/**
+ * All batch meta entities owned by this package. Hand to
+ * `DataSource#entityMetadatas` (or `entities:`) so TypeORM
+ * discovers them through the standard decorator scan.
+ */
+export const BATCH_META_ENTITIES = [
+  JobInstanceEntity,
+  JobExecutionEntity,
+  StepExecutionEntity,
+  JobExecutionContextEntity,
+  StepExecutionContextEntity,
+] as const;

package/src/index.ts

@@ -0,0 +1,42 @@
+// Public API barrel for @nest-batch/typeorm.
+//
+// The package is a **driver-agnostic adapter SLOT**. It owns the
+// `TypeOrmAdapter` factory, the `TypeOrmJobRepository` /
+// `TypeOrmTransactionManager` interface shape, and the
+// `TypeOrmDriverProvider` injection token. It does NOT import
+// `@nestjs/typeorm` (which carries the Postgres driver) — the
+// driver implementation lives in the `@nest-batch/postgresql` (or
+// `@nest-batch/mysql`) sibling package, which binds the
+// `TypeOrmDriverProvider` token to the concrete `DataSource`
+// in its own `forRoot()` factory.
+//
+// Apps wire the persistence concern into `NestBatchModule.forRoot()`
+// via the new `BatchAdapter` factory pattern:
+//
+//   import { NestBatchModule, InProcessAdapter } from '@nest-batch/core';
+//   import { TypeOrmAdapter } from '@nest-batch/typeorm';
+//   import { PostgresAdapter } from '@nest-batch/postgresql';
+//
+//   // The host must also call
+//   // `TypeOrmModule.forRoot({ ... })` in their `AppModule.imports`.
+//   // The PostgresAdapter.forRoot() factory binds the
+//   // TypeOrmDriverProvider token to the host's DataSource.
+//
+//   NestBatchModule.forRoot({
+//     adapters: {
+//       persistence: PostgresAdapter.forRoot(),
+//       transport: InProcessAdapter.forRoot(),
+//     },
+//   });
+//
+// The original `batchMetaEntities()` factory and the bundled
+// `CreateBatchMeta1700000000000` migration moved to
+// `@nest-batch/postgresql/src/migrations/`. The driver sibling owns
+// the TypeORM-specific entity classes and the migration scripts;
+// this package owns only the repository / transaction manager
+// shape and the driver-provider token.
+export { TypeOrmJobRepository } from './repository/typeorm-job-repository';
+export type { TypeOrmTransactionContext } from './transaction/typeorm-transaction-manager';
+export { TypeOrmTransactionManager } from './transaction/typeorm-transaction-manager';
+export * from './adapters';
+export * from './typeorm.driver-provider';

package/src/migrations/1700000000000-CreateBatchMeta.ts

@@ -0,0 +1,100 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Creates the six batch meta-tables owned by
+ * this package:
+ *
+ *   - batch_job_instance            (root, unique on (job_name, job_key))
+ *   - batch_job_execution           (one per job run, indexed by instance)
+ *   - batch_step_execution          (one per step run, indexed by exec)
+ *   - batch_job_execution_context   (JSON payload + version, keyed by exec)
+ *   - batch_step_execution_context  (JSON payload + version, keyed by step)
+ *
+ * This migration intentionally uses generic ANSI/PostgreSQL
+ * syntax (varchar + text + timestamptz + int). The adapter
+ * package's `typeorm-job-repository` is portable across SQLite
+ * (test database) and PostgreSQL (production). Users targeting
+ * MySQL or another driver should adjust the `down` (and
+ * optionally `up`) to match their column types.
+ *
+ * The `params` column on `batch_job_execution` is a JSON
+ * snapshot — stored as `text` to keep the schema portable and
+ * always serialized, never queried structurally.
+ */
+export class CreateBatchMeta1700000000000 implements MigrationInterface {
+  name = 'CreateBatchMeta1700000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "batch_job_instance" (
+        "id" varchar(255) PRIMARY KEY,
+        "job_name" varchar(255) NOT NULL,
+        "job_key" varchar(255) NOT NULL,
+        "created_at" timestamptz NOT NULL DEFAULT now(),
+        CONSTRAINT "batch_job_instance_job_name_job_key_unique" UNIQUE ("job_name", "job_key")
+      )
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "batch_job_execution" (
+        "id" varchar(255) PRIMARY KEY,
+        "job_instance_id" varchar(255) NOT NULL,
+        "status" varchar(20) NOT NULL,
+        "start_time" timestamptz NULL,
+        "end_time" timestamptz NULL,
+        "exit_code" varchar(255) NOT NULL DEFAULT '',
+        "exit_message" text NOT NULL DEFAULT '',
+        "params" text NOT NULL DEFAULT '{}'
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "batch_job_execution_job_instance_id_index"
+      ON "batch_job_execution" ("job_instance_id")
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "batch_step_execution" (
+        "id" varchar(255) PRIMARY KEY,
+        "job_execution_id" varchar(255) NOT NULL,
+        "step_name" varchar(255) NOT NULL,
+        "status" varchar(20) NOT NULL,
+        "read_count" int NOT NULL DEFAULT 0,
+        "write_count" int NOT NULL DEFAULT 0,
+        "skip_count" int NOT NULL DEFAULT 0,
+        "rollback_count" int NOT NULL DEFAULT 0,
+        "commit_count" int NOT NULL DEFAULT 0,
+        "exit_code" varchar(255) NOT NULL DEFAULT '',
+        "exit_message" text NOT NULL DEFAULT '',
+        "created_at" timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "batch_step_execution_job_execution_id_index"
+      ON "batch_step_execution" ("job_execution_id")
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "batch_job_execution_context" (
+        "job_execution_id" varchar(255) PRIMARY KEY,
+        "data" text NOT NULL,
+        "version" int NOT NULL DEFAULT 0
+      )
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "batch_step_execution_context" (
+        "step_execution_id" varchar(255) PRIMARY KEY,
+        "data" text NOT NULL,
+        "version" int NOT NULL DEFAULT 0
+      )
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS "batch_step_execution_context"`);
+    await queryRunner.query(`DROP TABLE IF EXISTS "batch_job_execution_context"`);
+    await queryRunner.query(`DROP TABLE IF EXISTS "batch_step_execution"`);
+    await queryRunner.query(`DROP TABLE IF EXISTS "batch_job_execution"`);
+    await queryRunner.query(`DROP TABLE IF EXISTS "batch_job_instance"`);
+  }
+}