@nest-batch/typeorm 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 easdkr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,263 @@
+# `@nest-batch/typeorm`
+
+The TypeORM 1.0.0 adapter for [`@nest-batch/core`](../core). It owns
+the same six Spring Batch-compatible batch meta-tables that
+`@nest-batch/mikro-orm` ships, expressed as TypeORM 1.0 entities plus
+a bundled migration. It exposes `TypeOrmJobRepository` and
+`TypeOrmTransactionManager` and runs the shared core contract suite
+against a real TypeORM `DataSource`.
+
+The package is a **sibling**, not a replacement. The dependency
+direction is strict and one-way:
+
+```
+@nest-batch/typeorm  ──▶  @nest-batch/core
+        │
+        └──────▶  typeorm (peer, ^1.0.0)
+```
+
+`@nest-batch/core` does not know this package exists. The boundary is
+enforced by a core test that fails the build if any `typeorm` import
+shows up in core.
+
+---
+
+## TypeORM 1.0.0-only policy
+
+This adapter targets **TypeORM 1.0.0 only**. The peer range is
+`typeorm: ^1.0.0` and intentionally excludes `0.3.x`.
+
+Why 1.0.0 and not 0.3? Two reasons:
+
+1. The `Connection` → `DataSource` rename. TypeORM 1.0.0 finished the
+   rename that 0.3 started; the API now exposes `DataSource`,
+   `DataSourceOptions`, and `DataSource.transaction()` instead of
+   `Connection`, `ConnectionOptions`, and `Connection.transaction()`.
+   Maintaining 0.3 support would mean running the full codebase
+   through `Connection → DataSource` shims, which is a waste of
+   effort when 0.3 is on a separate support track.
+2. The entity / migration surface. A few decorators and migration
+   helpers moved between 0.3 and 1.0. Supporting both means
+   conditional entity definitions, which is a smell.
+
+The peer range is `^1.0.0`, so any 1.x release works. The boundary
+test in core and a dedicated peer-range test in this package
+together ensure 0.3 does not silently sneak back in.
+
+If you're on TypeORM 0.3, stay on the previous
+`@nest-batch/nest-batch` package (pre-rename) or upgrade TypeORM
+first. There's no compatibility shim in this release.
+
+---
+
+## Install
+
+```bash
+pnpm add @nest-batch/typeorm
+```
+
+Peer dependencies the host must already provide:
+
+| Package            | Range         |
+| ------------------ | ------------- |
+| `@nest-batch/core` | `workspace:*` |
+| `typeorm`          | `^1.0.0`      |
+
+`typeorm` is a hard peer (declared in `peerDependencies` with
+`optional: false`). The `package.json` also lists it as a
+`devDependency` so the package's own test suite can resolve it
+without the host.
+
+---
+
+## Schema ownership
+
+This package owns the same six batch meta tables as
+`@nest-batch/mikro-orm`:
+
+| Table                          | Purpose                                                                            |
+| ------------------------------ | ---------------------------------------------------------------------------------- |
+| `batch_job_instance`           | One row per logical job (unique on `job_name`+`job_key`).                          |
+| `batch_job_execution`          | One row per job run. Holds status, start/end, exit code/message.                   |
+| `batch_job_execution_params`   | Composite-keyed params (one row per param name).                                   |
+| `batch_step_execution`         | One row per step run. Holds step status, exit code/message, last-chunk checkpoint. |
+| `batch_job_execution_context`  | JSON checkpoint + execution context (job-scoped).                                  |
+| `batch_step_execution_context` | JSON checkpoint + execution context (step-scoped).                                 |
+
+The bundled migration lives at
+`src/migrations/1700000000000-CreateBatchMeta.ts` and is exported
+as `CreateBatchMeta1700000000000` from the package root. Apps that
+already have a TypeORM migration directory should copy the file in
+and renumber it to fit their own migration sequence.
+
+> **Note:** The six batch meta entities are also exported as a
+> single tuple under `batchMetaEntities` from the package root.
+> Because the adapter no longer bootstraps the `DataSource` (the
+> host owns the `TypeOrmModule.forRoot()` call), spreading
+> `batchMetaEntities` into your own `entities` array is the only
+> way the meta tables are registered with TypeORM's metadata
+> system. Forgetting the spread means `Repository<Entity>` lookups
+> for the meta tables fail silently and the repository throws at
+> first call.
+
+> The migration uses `datetime` (not `timestamptz`) on the SQLite
+> test driver and `timestamptz` on PostgreSQL production. The
+> entities declare `datetime` for portability, and the migration
+> handler emits the right per-driver type. This is intentional:
+> the test suite runs against `better-sqlite3` for speed, and the
+> production driver is PostgreSQL.
+
+---
+
+## Wiring
+
+Wire the adapter with two imports in `AppModule.imports`: a host-
+owned `TypeOrmModule.forRoot()` call (which builds the
+`DataSource` and registers the meta entities) and a
+`TypeOrmAdapter.forRoot()` carrier passed to
+`NestBatchModule.forRoot({ adapters: { persistence, ... } })`.
+
+### Bring-your-own `DataSource` (recommended)
+
+If your app already uses `@nestjs/typeorm` (the typical case for a
+Nest app with user-domain entities), call
+`TypeOrmModule.forRoot()` yourself, spread `batchMetaEntities()`
+into its `entities` array, and pass the adapter's no-arg
+`TypeOrmAdapter.forRoot()` to `NestBatchModule.forRoot()` under
+`adapters.persistence`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { NestBatchModule } from '@nest-batch/core';
+import {
+  batchMetaEntities,
+  CreateBatchMeta1700000000000,
+  TypeOrmAdapter,
+} from '@nest-batch/typeorm';
+import { ProductEntity } from './entities/product.entity';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({
+      type: 'postgres',
+      host: '127.0.0.1',
+      port: 5434,
+      username: 'demo',
+      password: 'demo',
+      database: 'nest_batch_demo',
+      entities: [ProductEntity, ...batchMetaEntities()],
+      migrations: [CreateBatchMeta1700000000000 /* your other migrations */],
+      migrationsRun: true,
+    }),
+    NestBatchModule.forRoot({
+      adapters: { persistence: TypeOrmAdapter.forRoot() },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+`TypeOrmAdapter.forRoot()` takes no arguments on purpose. The host
+already owns the `TypeOrmModule.forRoot()` call; the adapter only
+declares its own provider and export surface. The
+`JOB_REPOSITORY_TOKEN` and `TRANSACTION_MANAGER_TOKEN` bindings are
+registered globally by the adapter, so you do **not** list
+`TypeOrmJobRepository` / `TypeOrmTransactionManager` in the
+`providers` array — they're already wired.
+
+> **Warning:** The adapter does **not** call `TypeOrmModule.forRoot()`
+> and does **not** create a `DataSource`. If you forget the
+> `TypeOrmModule.forRoot()` import, the app boots cleanly and the
+> batch module compiles, but the repository throws at first call
+> because `Repository<Entity>` resolution has nothing to bind to.
+> The two pieces are decoupled by design — the adapter is a
+> binding-only carrier, and the connection is the host's.
+
+> **Note:** `@nestjs/typeorm` defaults to `isGlobal: true`, which
+> is what the adapter assumes. Setting `isGlobal: false` breaks
+> `EntityManager` injection inside the adapter's own module: the
+> `DataSource` is registered on the host's `TypeOrmModule.forRoot()`
+> but the adapter module is `global: true`, so the `EntityManager`
+> token it needs is not exported across the boundary. Leave it at
+> the default unless you've wired an alternative.
+
+`forRootAsync` is the right call when the connection comes from a
+config service or a secret manager. Pass the standard `useFactory`
+plus `inject` list to `TypeOrmModule.forRootAsync()` and keep
+`TypeOrmAdapter.forRoot()` unchanged — the adapter doesn't care
+how the `DataSource` is built.
+
+### DataSource, not Connection
+
+TypeORM 1.0.0 calls it `DataSource`. The old `Connection` type is
+gone, and so is `getConnection()` / `getRepository()` on the
+connection. Every example in this README uses `DataSource`. If
+you're migrating from a 0.3 codebase, the rename touches every
+test file, every import, and every import path — there is no
+`@typeorm/0.3-compat` shim.
+
+The `TypeOrmTransactionManager` accepts a `DataSource` and uses
+`dataSource.transaction()` to start a real DB transaction. The
+callback receives a transactional `EntityManager`; use that one,
+not a globally-injected one, so all reads and writes are part of
+the same transaction.
+
+---
+
+## DB-first semantics
+
+The repository is the durable source of truth for execution state.
+Same model as the MikroORM adapter, same invariants:
+
+1. **The DB is canonical.** A BullMQ job is a correlation stamp, not
+   a state row. The `JobExecution` row carries the actual
+   `status`, `startTime`, `endTime`, `exitCode`, and `exitMessage`.
+2. **Atomic launches are enforced by the row lock.** The
+   `createExecutionAtomic` flow uses a transactional
+   `SELECT ... FOR UPDATE SKIP LOCKED` (on PostgreSQL) to serialize
+   concurrent launches. Two callers racing to launch the same
+   `jobName + jobKey` get one winner; the loser sees a thrown
+   `JobExecutionAlreadyRunningError`.
+3. **Restart and checkpoint go through the DB.** `findLatestStepExecution`
+   returns the most recent `StepExecution` for `(jobExecutionId, stepName)`
+   regardless of status, so the executor can load the
+   last-committed chunk index from
+   `batch_step_execution_context` and resume from there.
+
+The contract suite is the same one `@nest-batch/mikro-orm` runs. If
+you change the repository or transaction manager, run the suite to
+confirm you haven't broken the contract.
+
+---
+
+## What is NOT in this package
+
+- A TypeORM 0.3 adapter. Use 1.0.0 or stay on the previous package.
+- A Drizzle adapter. Drizzle is explicitly excluded from this
+  release. See `MIGRATION.md`.
+- A MikroORM adapter. Use `@nest-batch/mikro-orm` if you want
+  MikroORM 6; the two packages expose the same six-table schema.
+- A transport. Use `@nest-batch/bullmq` to wire BullMQ as the
+  execution strategy; the transport layer reads the same
+  `JobExecution` rows.
+- An admin UI, metrics, tracing, webhook, or job visualization
+  surface. Out of scope for the whole `@nest-batch/*` family.
+
+---
+
+## Scripts
+
+```bash
+pnpm --filter @nest-batch/typeorm build      # SWC transpile + tsc declarations
+pnpm --filter @nest-batch/typeorm test       # vitest run (uses better-sqlite3 by default)
+pnpm --filter @nest-batch/typeorm test:watch # vitest watch
+pnpm --filter @nest-batch/typeorm typecheck  # tsc --noEmit
+```
+
+The contract suite runs against an in-memory SQLite database by
+default. The test driver is `better-sqlite3` because it gives
+sub-millisecond setup and teardown, and the contract tests are
+database-agnostic enough to not need a full PostgreSQL harness.
+For an end-to-end Postgres run, point the suite at your own
+`DataSource` via the documented test harness hook.

package/dist/src/adapters/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,mBAAmB,CAAC"}

package/dist/src/adapters/index.js

@@ -0,0 +1,35 @@
+/**
+ * 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, ... } })`).
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./typeorm.adapter"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/src/adapters/index.js.map

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

package/dist/src/adapters/typeorm.adapter.d.ts

@@ -0,0 +1,42 @@
+import { type BatchAdapter } from '@nest-batch/core';
+/**
+ * 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).
+ */
+export declare 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 declare 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;
+}
+//# sourceMappingURL=typeorm.adapter.d.ts.map

package/dist/src/adapters/typeorm.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm.adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/typeorm.adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAC;AAK1B;;;;;;;;;GASG;AACH,qBACa,kBAAkB;CAAG;AAElC;;;;;;;;;;GAUG;AACH,qBAAa,cAAc;IACzB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,OAAO,IAAI,YAAY;CA6B/B"}

package/dist/src/adapters/typeorm.adapter.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get TypeOrmAdapter () {
+        return TypeOrmAdapter;
+    },
+    get TypeOrmBatchModule () {
+        return TypeOrmBatchModule;
+    }
+});
+const _common = require("@nestjs/common");
+const _core = require("@nest-batch/core");
+const _typeormjobrepository = require("../repository/typeorm-job-repository");
+const _typeormtransactionmanager = require("../transaction/typeorm-transaction-manager");
+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;
+}
+let TypeOrmBatchModule = class TypeOrmBatchModule {
+};
+TypeOrmBatchModule = _ts_decorate([
+    (0, _common.Module)({})
+], TypeOrmBatchModule);
+let TypeOrmAdapter = 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() {
+        return {
+            name: 'typeorm',
+            module: {
+                module: TypeOrmBatchModule,
+                global: true,
+                providers: [
+                    _typeormjobrepository.TypeOrmJobRepository,
+                    _typeormtransactionmanager.TypeOrmTransactionManager,
+                    {
+                        provide: _core.JOB_REPOSITORY_TOKEN,
+                        useExisting: _typeormjobrepository.TypeOrmJobRepository
+                    },
+                    {
+                        provide: _core.TRANSACTION_MANAGER_TOKEN,
+                        useExisting: _typeormtransactionmanager.TypeOrmTransactionManager
+                    }
+                ],
+                exports: [
+                    _core.JOB_REPOSITORY_TOKEN,
+                    _core.TRANSACTION_MANAGER_TOKEN
+                ]
+            },
+            globalProviders: [
+                {
+                    provide: _core.JOB_REPOSITORY_TOKEN,
+                    useClass: _typeormjobrepository.TypeOrmJobRepository
+                },
+                {
+                    provide: _core.TRANSACTION_MANAGER_TOKEN,
+                    useClass: _typeormtransactionmanager.TypeOrmTransactionManager
+                }
+            ]
+        };
+    }
+};
+
+//# sourceMappingURL=typeorm.adapter.js.map

package/dist/src/adapters/typeorm.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/typeorm.adapter.ts"],"sourcesContent":["import { Module } from '@nestjs/common';\n\nimport {\n  JOB_REPOSITORY_TOKEN,\n  TRANSACTION_MANAGER_TOKEN,\n  type BatchAdapter,\n} from '@nest-batch/core';\n\nimport { TypeOrmJobRepository } from '../repository/typeorm-job-repository';\nimport { TypeOrmTransactionManager } from '../transaction/typeorm-transaction-manager';\n\n/**\n * Empty Nest module class that owns the TypeORM batch adapter\n * providers.\n *\n * The class has no body on purpose: it is purely a `DynamicModule`\n * carrier for the `forRoot()` factory below. Nest's module system\n * requires *some* class to identify the module — the empty class\n * is the minimum possible surface and keeps the runtime allocation\n * at one class (no decorators, no lifecycle hooks, no metadata).\n */\n@Module({})\nexport class TypeOrmBatchModule {}\n\n/**\n * `TypeOrmAdapter` — the TypeORM 1.0.0 persistence adapter for\n * `@nest-batch/core`.\n *\n * It owns the `JOB_REPOSITORY_TOKEN` and `TRANSACTION_MANAGER_TOKEN`\n * bindings to the TypeORM-backed `TypeOrmJobRepository` /\n * `TypeOrmTransactionManager` implementations. This adapter does\n * not call `TypeOrmModule.forRoot()` — the host must call it in\n * `AppModule.imports` (and register the six batch meta entities\n * on the resulting `DataSource`).\n */\nexport class TypeOrmAdapter {\n  /**\n   * Build the `BatchAdapter` value the new factory-pattern\n   * `NestBatchModule.forRoot({ adapters: { persistence, ... } })`\n   * expects.\n   *\n   * No options are accepted on purpose — the host already owns\n   * the `TypeOrmModule.forRoot(...)` call. The adapter only needs\n   * to declare its own provider / export / `globalProviders`\n   * surface; the `DataSource` itself is the host's responsibility.\n   *\n   * @returns A `BatchAdapter` whose `module` is a `global: true`\n   *   `DynamicModule` exposing `JOB_REPOSITORY_TOKEN` and\n   *   `TRANSACTION_MANAGER_TOKEN` to the host application.\n   */\n  static forRoot(): BatchAdapter {\n    return {\n      name: 'typeorm',\n      module: {\n        module: TypeOrmBatchModule,\n        global: true,\n        providers: [\n          TypeOrmJobRepository,\n          TypeOrmTransactionManager,\n          {\n            provide: JOB_REPOSITORY_TOKEN,\n            useExisting: TypeOrmJobRepository,\n          },\n          {\n            provide: TRANSACTION_MANAGER_TOKEN,\n            useExisting: TypeOrmTransactionManager,\n          },\n        ],\n        exports: [JOB_REPOSITORY_TOKEN, TRANSACTION_MANAGER_TOKEN],\n      },\n      globalProviders: [\n        { provide: JOB_REPOSITORY_TOKEN, useClass: TypeOrmJobRepository },\n        {\n          provide: TRANSACTION_MANAGER_TOKEN,\n          useClass: TypeOrmTransactionManager,\n        },\n      ],\n    };\n  }\n}\n\n\n"],"names":["TypeOrmAdapter","TypeOrmBatchModule","forRoot","name","module","global","providers","TypeOrmJobRepository","TypeOrmTransactionManager","provide","JOB_REPOSITORY_TOKEN","useExisting","TRANSACTION_MANAGER_TOKEN","exports","globalProviders","useClass"],"mappings":";;;;;;;;;;;QAmCaA;eAAAA;;QAbAC;eAAAA;;;wBAtBU;sBAMhB;sCAE8B;2CACK;;;;;;;AAanC,IAAA,AAAMA,qBAAN,MAAMA;AAAoB;;;;AAa1B,IAAA,AAAMD,iBAAN,MAAMA;IACX;;;;;;;;;;;;;GAaC,GACD,OAAOE,UAAwB;QAC7B,OAAO;YACLC,MAAM;YACNC,QAAQ;gBACNA,QAAQH;gBACRI,QAAQ;gBACRC,WAAW;oBACTC,0CAAoB;oBACpBC,oDAAyB;oBACzB;wBACEC,SAASC,0BAAoB;wBAC7BC,aAAaJ,0CAAoB;oBACnC;oBACA;wBACEE,SAASG,+BAAyB;wBAClCD,aAAaH,oDAAyB;oBACxC;iBACD;gBACDK,SAAS;oBAACH,0BAAoB;oBAAEE,+BAAyB;iBAAC;YAC5D;YACAE,iBAAiB;gBACf;oBAAEL,SAASC,0BAAoB;oBAAEK,UAAUR,0CAAoB;gBAAC;gBAChE;oBACEE,SAASG,+BAAyB;oBAClCG,UAAUP,oDAAyB;gBACrC;aACD;QACH;IACF;AACF"}

package/dist/src/entities/index.d.ts

@@ -0,0 +1,2 @@
+export * from './job-meta.entities';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/entities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/src/entities/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./job-meta.entities"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/src/entities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/entities/index.ts"],"sourcesContent":["export * from './job-meta.entities';\n"],"names":[],"mappings":";;;;qBAAc"}

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

@@ -0,0 +1,96 @@
+/**
+ * `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.
+ */
+export declare class JobInstanceEntity {
+    id: string;
+    jobName: string;
+    jobKey: string;
+    createdAt: 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.
+ */
+export declare class JobExecutionEntity {
+    id: string;
+    jobInstanceId: string;
+    status: string;
+    startTime: Date | null;
+    endTime: Date | null;
+    exitCode: string;
+    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.
+     */
+    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.
+ */
+export declare class StepExecutionEntity {
+    id: string;
+    jobExecutionId: string;
+    stepName: string;
+    status: string;
+    readCount: number;
+    writeCount: number;
+    skipCount: number;
+    rollbackCount: number;
+    commitCount: number;
+    exitCode: string;
+    exitMessage: string;
+    createdAt: Date;
+}
+/**
+ * `batch_job_execution_context` metadata row.
+ *
+ * `data` is a JSON-serialized ExecutionContext payload. `version`
+ * guards against lost updates during concurrent writers.
+ */
+export declare class JobExecutionContextEntity {
+    jobExecutionId: string;
+    data: string;
+    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.
+ */
+export declare class StepExecutionContextEntity {
+    stepExecutionId: string;
+    data: string;
+    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 declare const BATCH_META_ENTITIES: readonly [typeof JobInstanceEntity, typeof JobExecutionEntity, typeof StepExecutionEntity, typeof JobExecutionContextEntity, typeof StepExecutionContextEntity];
+//# sourceMappingURL=job-meta.entities.d.ts.map

package/dist/src/entities/job-meta.entities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-meta.entities.d.ts","sourceRoot":"","sources":["../../../src/entities/job-meta.entities.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,qBAEa,iBAAiB;IAE5B,EAAE,EAAG,MAAM,CAAC;IAGZ,OAAO,EAAG,MAAM,CAAC;IAGjB,MAAM,EAAG,MAAM,CAAC;IAYhB,SAAS,EAAE,IAAI,CAAc;CAC9B;AAED;;;;;;;;GAQG;AACH,qBAEa,kBAAkB;IAE7B,EAAE,EAAG,MAAM,CAAC;IAGZ,aAAa,EAAG,MAAM,CAAC;IAGvB,MAAM,EAAG,MAAM,CAAC;IAGhB,SAAS,EAAE,IAAI,GAAG,IAAI,CAAQ;IAG9B,OAAO,EAAE,IAAI,GAAG,IAAI,CAAQ;IAG5B,QAAQ,EAAG,MAAM,CAAC;IAGlB,WAAW,EAAG,MAAM,CAAC;IAErB;;;;;OAKG;IAEH,MAAM,EAAG,MAAM,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,qBAEa,mBAAmB;IAE9B,EAAE,EAAG,MAAM,CAAC;IAGZ,cAAc,EAAG,MAAM,CAAC;IAGxB,QAAQ,EAAG,MAAM,CAAC;IAGlB,MAAM,EAAG,MAAM,CAAC;IAGhB,SAAS,EAAG,MAAM,CAAC;IAGnB,UAAU,EAAG,MAAM,CAAC;IAGpB,SAAS,EAAG,MAAM,CAAC;IAGnB,aAAa,EAAG,MAAM,CAAC;IAGvB,WAAW,EAAG,MAAM,CAAC;IAGrB,QAAQ,EAAG,MAAM,CAAC;IAGlB,WAAW,EAAG,MAAM,CAAC;IAOrB,SAAS,EAAE,IAAI,CAAc;CAC9B;AAED;;;;;GAKG;AACH,qBACa,yBAAyB;IAEpC,cAAc,EAAG,MAAM,CAAC;IAGxB,IAAI,EAAG,MAAM,CAAC;IAGd,OAAO,EAAG,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,qBACa,0BAA0B;IAErC,eAAe,EAAG,MAAM,CAAC;IAGzB,IAAI,EAAG,MAAM,CAAC;IAGd,OAAO,EAAG,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,iKAMtB,CAAC"}