@nest-batch/typeorm 0.2.0

package/dist/src/entities/job-meta.entities.js

@@ -0,0 +1,357 @@
+"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 BATCH_META_ENTITIES () {
+        return BATCH_META_ENTITIES;
+    },
+    get JobExecutionContextEntity () {
+        return JobExecutionContextEntity;
+    },
+    get JobExecutionEntity () {
+        return JobExecutionEntity;
+    },
+    get JobInstanceEntity () {
+        return JobInstanceEntity;
+    },
+    get StepExecutionContextEntity () {
+        return StepExecutionContextEntity;
+    },
+    get StepExecutionEntity () {
+        return StepExecutionEntity;
+    }
+});
+const _typeorm = require("typeorm");
+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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+let JobInstanceEntity = class JobInstanceEntity {
+    id;
+    jobName;
+    jobKey;
+    createdAt = new Date();
+};
+_ts_decorate([
+    (0, _typeorm.PrimaryColumn)({
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], JobInstanceEntity.prototype, "id", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'job_name',
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], JobInstanceEntity.prototype, "jobName", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'job_key',
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], JobInstanceEntity.prototype, "jobKey", void 0);
+_ts_decorate([
+    (0, _typeorm.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'
+    }),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], JobInstanceEntity.prototype, "createdAt", void 0);
+JobInstanceEntity = _ts_decorate([
+    (0, _typeorm.Entity)('batch_job_instance'),
+    (0, _typeorm.Index)('batch_job_instance_job_name_job_key_unique', [
+        'jobName',
+        'jobKey'
+    ], {
+        unique: true
+    })
+], JobInstanceEntity);
+let JobExecutionEntity = class JobExecutionEntity {
+    id;
+    jobInstanceId;
+    status;
+    startTime = null;
+    endTime = null;
+    exitCode;
+    exitMessage;
+    /**
+   * 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;
+};
+_ts_decorate([
+    (0, _typeorm.PrimaryColumn)({
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], JobExecutionEntity.prototype, "id", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'job_instance_id',
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], JobExecutionEntity.prototype, "jobInstanceId", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'varchar',
+        length: 20
+    }),
+    _ts_metadata("design:type", String)
+], JobExecutionEntity.prototype, "status", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'start_time',
+        type: 'datetime',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], JobExecutionEntity.prototype, "startTime", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'end_time',
+        type: 'datetime',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], JobExecutionEntity.prototype, "endTime", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'exit_code',
+        type: 'varchar',
+        length: 255,
+        default: ''
+    }),
+    _ts_metadata("design:type", String)
+], JobExecutionEntity.prototype, "exitCode", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'exit_message',
+        type: 'text',
+        default: ''
+    }),
+    _ts_metadata("design:type", String)
+], JobExecutionEntity.prototype, "exitMessage", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'params',
+        type: 'text',
+        default: '{}'
+    }),
+    _ts_metadata("design:type", String)
+], JobExecutionEntity.prototype, "params", void 0);
+JobExecutionEntity = _ts_decorate([
+    (0, _typeorm.Entity)('batch_job_execution'),
+    (0, _typeorm.Index)('batch_job_execution_job_instance_id_index', [
+        'jobInstanceId'
+    ])
+], JobExecutionEntity);
+let StepExecutionEntity = class StepExecutionEntity {
+    id;
+    jobExecutionId;
+    stepName;
+    status;
+    readCount;
+    writeCount;
+    skipCount;
+    rollbackCount;
+    commitCount;
+    exitCode;
+    exitMessage;
+    createdAt = new Date();
+};
+_ts_decorate([
+    (0, _typeorm.PrimaryColumn)({
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], StepExecutionEntity.prototype, "id", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'job_execution_id',
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], StepExecutionEntity.prototype, "jobExecutionId", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'step_name',
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], StepExecutionEntity.prototype, "stepName", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'varchar',
+        length: 20
+    }),
+    _ts_metadata("design:type", String)
+], StepExecutionEntity.prototype, "status", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'read_count',
+        type: 'int',
+        default: 0
+    }),
+    _ts_metadata("design:type", Number)
+], StepExecutionEntity.prototype, "readCount", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'write_count',
+        type: 'int',
+        default: 0
+    }),
+    _ts_metadata("design:type", Number)
+], StepExecutionEntity.prototype, "writeCount", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'skip_count',
+        type: 'int',
+        default: 0
+    }),
+    _ts_metadata("design:type", Number)
+], StepExecutionEntity.prototype, "skipCount", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'rollback_count',
+        type: 'int',
+        default: 0
+    }),
+    _ts_metadata("design:type", Number)
+], StepExecutionEntity.prototype, "rollbackCount", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'commit_count',
+        type: 'int',
+        default: 0
+    }),
+    _ts_metadata("design:type", Number)
+], StepExecutionEntity.prototype, "commitCount", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'exit_code',
+        type: 'varchar',
+        length: 255,
+        default: ''
+    }),
+    _ts_metadata("design:type", String)
+], StepExecutionEntity.prototype, "exitCode", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'exit_message',
+        type: 'text',
+        default: ''
+    }),
+    _ts_metadata("design:type", String)
+], StepExecutionEntity.prototype, "exitMessage", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        name: 'created_at',
+        type: 'datetime',
+        default: ()=>'CURRENT_TIMESTAMP'
+    }),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], StepExecutionEntity.prototype, "createdAt", void 0);
+StepExecutionEntity = _ts_decorate([
+    (0, _typeorm.Entity)('batch_step_execution'),
+    (0, _typeorm.Index)('batch_step_execution_job_execution_id_index', [
+        'jobExecutionId'
+    ])
+], StepExecutionEntity);
+let JobExecutionContextEntity = class JobExecutionContextEntity {
+    jobExecutionId;
+    data;
+    version;
+};
+_ts_decorate([
+    (0, _typeorm.PrimaryColumn)({
+        name: 'job_execution_id',
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], JobExecutionContextEntity.prototype, "jobExecutionId", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'text'
+    }),
+    _ts_metadata("design:type", String)
+], JobExecutionContextEntity.prototype, "data", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'int',
+        default: 0
+    }),
+    _ts_metadata("design:type", Number)
+], JobExecutionContextEntity.prototype, "version", void 0);
+JobExecutionContextEntity = _ts_decorate([
+    (0, _typeorm.Entity)('batch_job_execution_context')
+], JobExecutionContextEntity);
+let StepExecutionContextEntity = class StepExecutionContextEntity {
+    stepExecutionId;
+    data;
+    version;
+};
+_ts_decorate([
+    (0, _typeorm.PrimaryColumn)({
+        name: 'step_execution_id',
+        type: 'varchar',
+        length: 255
+    }),
+    _ts_metadata("design:type", String)
+], StepExecutionContextEntity.prototype, "stepExecutionId", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'text'
+    }),
+    _ts_metadata("design:type", String)
+], StepExecutionContextEntity.prototype, "data", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'int',
+        default: 0
+    }),
+    _ts_metadata("design:type", Number)
+], StepExecutionContextEntity.prototype, "version", void 0);
+StepExecutionContextEntity = _ts_decorate([
+    (0, _typeorm.Entity)('batch_step_execution_context')
+], StepExecutionContextEntity);
+const BATCH_META_ENTITIES = [
+    JobInstanceEntity,
+    JobExecutionEntity,
+    StepExecutionEntity,
+    JobExecutionContextEntity,
+    StepExecutionContextEntity
+];
+
+//# sourceMappingURL=job-meta.entities.js.map

package/dist/src/entities/job-meta.entities.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/entities/job-meta.entities.ts"],"sourcesContent":["import { Entity, PrimaryColumn, Column, Index } from 'typeorm';\n\n/**\n * `batch_job_instance` metadata row.\n *\n * One row per logical job instance. Uniqueness is enforced on\n * (jobName, jobKey) so that the same canonical key resolves to the\n * same instance across restarts. The composite unique index is\n * declared on the entity and is also reified in the bundled\n * migration under the same name.\n */\n@Entity('batch_job_instance')\n@Index('batch_job_instance_job_name_job_key_unique', ['jobName', 'jobKey'], { unique: true })\nexport class JobInstanceEntity {\n  @PrimaryColumn({ type: 'varchar', length: 255 })\n  id!: string;\n\n  @Column({ name: 'job_name', type: 'varchar', length: 255 })\n  jobName!: string;\n\n  @Column({ name: 'job_key', type: 'varchar', length: 255 })\n  jobKey!: string;\n\n  @Column({\n    name: 'created_at',\n    // `datetime` is portable across PostgreSQL and SQLite (the test\n    // driver). The bundled migration uses timestamptz on\n    // PostgreSQL by hand; SQLite loses the timezone qualifier,\n    // which is acceptable for a creation-time stamp that is never\n    // compared with sub-second precision in queries.\n    type: 'datetime',\n    default: () => 'CURRENT_TIMESTAMP',\n  })\n  createdAt: Date = new Date();\n}\n\n/**\n * `batch_job_execution` metadata row.\n *\n * One row per job run. `status` is the stringified JobStatus enum\n * (kept as a plain varchar — TypeORM enum support varies across\n * drivers and v1.0.0 dropped a few columns we don't need). The\n * `jobInstanceId` column is indexed because every contract lookup\n * (\"is this instance running?\") scans by it.\n */\n@Entity('batch_job_execution')\n@Index('batch_job_execution_job_instance_id_index', ['jobInstanceId'])\nexport class JobExecutionEntity {\n  @PrimaryColumn({ type: 'varchar', length: 255 })\n  id!: string;\n\n  @Column({ name: 'job_instance_id', type: 'varchar', length: 255 })\n  jobInstanceId!: string;\n\n  @Column({ type: 'varchar', length: 20 })\n  status!: string;\n\n  @Column({ name: 'start_time', type: 'datetime', nullable: true })\n  startTime: Date | null = null;\n\n  @Column({ name: 'end_time', type: 'datetime', nullable: true })\n  endTime: Date | null = null;\n\n  @Column({ name: 'exit_code', type: 'varchar', length: 255, default: '' })\n  exitCode!: string;\n\n  @Column({ name: 'exit_message', type: 'text', default: '' })\n  exitMessage!: string;\n\n  /**\n   * JSON-serialized `JobParameters` snapshot. Stored as `text` (not\n   * native `jsonb`) so the adapter works uniformly across SQLite (used\n   * in unit tests) and PostgreSQL/MySQL — the column is always a\n   * serialized payload, never queried by the ORM.\n   */\n  @Column({ name: 'params', type: 'text', default: '{}' })\n  params!: string;\n}\n\n/**\n * `batch_step_execution` metadata row.\n *\n * One row per step run. Counters default to 0 so the entity can\n * be persisted immediately upon creation, before any items are\n * processed. `createdAt` is stamped on insert and used by\n * `findLatestStepExecution` to resolve the most recently created\n * step for a given `(jobExecutionId, stepName)` pair — a v4 UUID\n * primary key does not preserve insertion order, so an explicit\n * monotonic column is required.\n */\n@Entity('batch_step_execution')\n@Index('batch_step_execution_job_execution_id_index', ['jobExecutionId'])\nexport class StepExecutionEntity {\n  @PrimaryColumn({ type: 'varchar', length: 255 })\n  id!: string;\n\n  @Column({ name: 'job_execution_id', type: 'varchar', length: 255 })\n  jobExecutionId!: string;\n\n  @Column({ name: 'step_name', type: 'varchar', length: 255 })\n  stepName!: string;\n\n  @Column({ type: 'varchar', length: 20 })\n  status!: string;\n\n  @Column({ name: 'read_count', type: 'int', default: 0 })\n  readCount!: number;\n\n  @Column({ name: 'write_count', type: 'int', default: 0 })\n  writeCount!: number;\n\n  @Column({ name: 'skip_count', type: 'int', default: 0 })\n  skipCount!: number;\n\n  @Column({ name: 'rollback_count', type: 'int', default: 0 })\n  rollbackCount!: number;\n\n  @Column({ name: 'commit_count', type: 'int', default: 0 })\n  commitCount!: number;\n\n  @Column({ name: 'exit_code', type: 'varchar', length: 255, default: '' })\n  exitCode!: string;\n\n  @Column({ name: 'exit_message', type: 'text', default: '' })\n  exitMessage!: string;\n\n  @Column({\n    name: 'created_at',\n    type: 'datetime',\n    default: () => 'CURRENT_TIMESTAMP',\n  })\n  createdAt: Date = new Date();\n}\n\n/**\n * `batch_job_execution_context` metadata row.\n *\n * `data` is a JSON-serialized ExecutionContext payload. `version`\n * guards against lost updates during concurrent writers.\n */\n@Entity('batch_job_execution_context')\nexport class JobExecutionContextEntity {\n  @PrimaryColumn({ name: 'job_execution_id', type: 'varchar', length: 255 })\n  jobExecutionId!: string;\n\n  @Column({ type: 'text' })\n  data!: string;\n\n  @Column({ type: 'int', default: 0 })\n  version!: number;\n}\n\n/**\n * `batch_step_execution_context` metadata row.\n *\n * Mirrors the job-level context table but scoped to a single\n * step execution. There is intentionally no params sibling table\n * for steps — step parameters are derivable from the parent job\n * execution params + the step execution context.\n */\n@Entity('batch_step_execution_context')\nexport class StepExecutionContextEntity {\n  @PrimaryColumn({ name: 'step_execution_id', type: 'varchar', length: 255 })\n  stepExecutionId!: string;\n\n  @Column({ type: 'text' })\n  data!: string;\n\n  @Column({ type: 'int', default: 0 })\n  version!: number;\n}\n\n/**\n * All batch meta entities owned by this package. Hand to\n * `DataSource#entityMetadatas` (or `entities:`) so TypeORM\n * discovers them through the standard decorator scan.\n */\nexport const BATCH_META_ENTITIES = [\n  JobInstanceEntity,\n  JobExecutionEntity,\n  StepExecutionEntity,\n  JobExecutionContextEntity,\n  StepExecutionContextEntity,\n] as const;\n"],"names":["BATCH_META_ENTITIES","JobExecutionContextEntity","JobExecutionEntity","JobInstanceEntity","StepExecutionContextEntity","StepExecutionEntity","id","jobName","jobKey","createdAt","Date","type","length","name","default","unique","jobInstanceId","status","startTime","endTime","exitCode","exitMessage","params","nullable","jobExecutionId","stepName","readCount","writeCount","skipCount","rollbackCount","commitCount","data","version","stepExecutionId"],"mappings":";;;;;;;;;;;QAiLaA;eAAAA;;QApCAC;eAAAA;;QA9FAC;eAAAA;;QAlCAC;eAAAA;;QAoJAC;eAAAA;;QArEAC;eAAAA;;;yBA5FwC;;;;;;;;;;AAa9C,IAAA,AAAMF,oBAAN,MAAMA;IAEXG,GAAY;IAGZC,QAAiB;IAGjBC,OAAgB;IAYhBC,YAAkB,IAAIC,OAAO;AAC/B;;;QApBmBC,MAAM;QAAWC,QAAQ;;;;;;QAGhCC,MAAM;QAAYF,MAAM;QAAWC,QAAQ;;;;;;QAG3CC,MAAM;QAAWF,MAAM;QAAWC,QAAQ;;;;;;QAIlDC,MAAM;QACN,gEAAgE;QAChE,qDAAqD;QACrD,2DAA2D;QAC3D,8DAA8D;QAC9D,iDAAiD;QACjDF,MAAM;QACNG,SAAS,IAAM;;;;;;;QAnBmC;QAAW;;QAAaC,QAAQ;;;AAmC/E,IAAA,AAAMb,qBAAN,MAAMA;IAEXI,GAAY;IAGZU,cAAuB;IAGvBC,OAAgB;IAGhBC,YAAyB,KAAK;IAG9BC,UAAuB,KAAK;IAG5BC,SAAkB;IAGlBC,YAAqB;IAErB;;;;;GAKC,GACD,AACAC,OAAgB;AAClB;;;QA7BmBX,MAAM;QAAWC,QAAQ;;;;;;QAGhCC,MAAM;QAAmBF,MAAM;QAAWC,QAAQ;;;;;;QAGlDD,MAAM;QAAWC,QAAQ;;;;;;QAGzBC,MAAM;QAAcF,MAAM;QAAYY,UAAU;;;;;;QAGhDV,MAAM;QAAYF,MAAM;QAAYY,UAAU;;;;;;QAG9CV,MAAM;QAAaF,MAAM;QAAWC,QAAQ;QAAKE,SAAS;;;;;;QAG1DD,MAAM;QAAgBF,MAAM;QAAQG,SAAS;;;;;;QAS7CD,MAAM;QAAUF,MAAM;QAAQG,SAAS;;;;;;;QA7BE;;;AA8C9C,IAAA,AAAMT,sBAAN,MAAMA;IAEXC,GAAY;IAGZkB,eAAwB;IAGxBC,SAAkB;IAGlBR,OAAgB;IAGhBS,UAAmB;IAGnBC,WAAoB;IAGpBC,UAAmB;IAGnBC,cAAuB;IAGvBC,YAAqB;IAGrBV,SAAkB;IAGlBC,YAAqB;IAOrBZ,YAAkB,IAAIC,OAAO;AAC/B;;;QAvCmBC,MAAM;QAAWC,QAAQ;;;;;;QAGhCC,MAAM;QAAoBF,MAAM;QAAWC,QAAQ;;;;;;QAGnDC,MAAM;QAAaF,MAAM;QAAWC,QAAQ;;;;;;QAG5CD,MAAM;QAAWC,QAAQ;;;;;;QAGzBC,MAAM;QAAcF,MAAM;QAAOG,SAAS;;;;;;QAG1CD,MAAM;QAAeF,MAAM;QAAOG,SAAS;;;;;;QAG3CD,MAAM;QAAcF,MAAM;QAAOG,SAAS;;;;;;QAG1CD,MAAM;QAAkBF,MAAM;QAAOG,SAAS;;;;;;QAG9CD,MAAM;QAAgBF,MAAM;QAAOG,SAAS;;;;;;QAG5CD,MAAM;QAAaF,MAAM;QAAWC,QAAQ;QAAKE,SAAS;;;;;;QAG1DD,MAAM;QAAgBF,MAAM;QAAQG,SAAS;;;;;;QAIrDD,MAAM;QACNF,MAAM;QACNG,SAAS,IAAM;;;;;;;QAtCoC;;;AAkDhD,IAAA,AAAMb,4BAAN,MAAMA;IAEXuB,eAAwB;IAGxBO,KAAc;IAGdC,QAAiB;AACnB;;;QARmBnB,MAAM;QAAoBF,MAAM;QAAWC,QAAQ;;;;;;QAG1DD,MAAM;;;;;;QAGNA,MAAM;QAAOG,SAAS;;;;;;;AAa3B,IAAA,AAAMV,6BAAN,MAAMA;IAEX6B,gBAAyB;IAGzBF,KAAc;IAGdC,QAAiB;AACnB;;;QARmBnB,MAAM;QAAqBF,MAAM;QAAWC,QAAQ;;;;;;QAG3DD,MAAM;;;;;;QAGNA,MAAM;QAAOG,SAAS;;;;;;;AAS3B,MAAMd,sBAAsB;IACjCG;IACAD;IACAG;IACAJ;IACAG;CACD"}

package/dist/src/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAqCA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,YAAY,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAC3F,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AACtF,cAAc,YAAY,CAAC;AAC3B,cAAc,2BAA2B,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,74 @@
+// 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.
+"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 TypeOrmJobRepository () {
+        return _typeormjobrepository.TypeOrmJobRepository;
+    },
+    get TypeOrmTransactionManager () {
+        return _typeormtransactionmanager.TypeOrmTransactionManager;
+    }
+});
+const _typeormjobrepository = require("./repository/typeorm-job-repository");
+const _typeormtransactionmanager = require("./transaction/typeorm-transaction-manager");
+_export_star(require("./adapters"), exports);
+_export_star(require("./typeorm.driver-provider"), 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/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["// Public API barrel for @nest-batch/typeorm.\n//\n// The package is a **driver-agnostic adapter SLOT**. It owns the\n// `TypeOrmAdapter` factory, the `TypeOrmJobRepository` /\n// `TypeOrmTransactionManager` interface shape, and the\n// `TypeOrmDriverProvider` injection token. It does NOT import\n// `@nestjs/typeorm` (which carries the Postgres driver) — the\n// driver implementation lives in the `@nest-batch/postgresql` (or\n// `@nest-batch/mysql`) sibling package, which binds the\n// `TypeOrmDriverProvider` token to the concrete `DataSource`\n// in its own `forRoot()` factory.\n//\n// Apps wire the persistence concern into `NestBatchModule.forRoot()`\n// via the new `BatchAdapter` factory pattern:\n//\n//   import { NestBatchModule, InProcessAdapter } from '@nest-batch/core';\n//   import { TypeOrmAdapter } from '@nest-batch/typeorm';\n//   import { PostgresAdapter } from '@nest-batch/postgresql';\n//\n//   // The host must also call\n//   // `TypeOrmModule.forRoot({ ... })` in their `AppModule.imports`.\n//   // The PostgresAdapter.forRoot() factory binds the\n//   // TypeOrmDriverProvider token to the host's DataSource.\n//\n//   NestBatchModule.forRoot({\n//     adapters: {\n//       persistence: PostgresAdapter.forRoot(),\n//       transport: InProcessAdapter.forRoot(),\n//     },\n//   });\n//\n// The original `batchMetaEntities()` factory and the bundled\n// `CreateBatchMeta1700000000000` migration moved to\n// `@nest-batch/postgresql/src/migrations/`. The driver sibling owns\n// the TypeORM-specific entity classes and the migration scripts;\n// this package owns only the repository / transaction manager\n// shape and the driver-provider token.\nexport { TypeOrmJobRepository } from './repository/typeorm-job-repository';\nexport type { TypeOrmTransactionContext } from './transaction/typeorm-transaction-manager';\nexport { TypeOrmTransactionManager } from './transaction/typeorm-transaction-manager';\nexport * from './adapters';\nexport * from './typeorm.driver-provider';\n"],"names":["TypeOrmJobRepository","TypeOrmTransactionManager"],"mappings":"AAAA,6CAA6C;AAC7C,EAAE;AACF,iEAAiE;AACjE,yDAAyD;AACzD,uDAAuD;AACvD,8DAA8D;AAC9D,8DAA8D;AAC9D,kEAAkE;AAClE,wDAAwD;AACxD,6DAA6D;AAC7D,kCAAkC;AAClC,EAAE;AACF,qEAAqE;AACrE,8CAA8C;AAC9C,EAAE;AACF,0EAA0E;AAC1E,0DAA0D;AAC1D,8DAA8D;AAC9D,EAAE;AACF,+BAA+B;AAC/B,sEAAsE;AACtE,uDAAuD;AACvD,6DAA6D;AAC7D,EAAE;AACF,8BAA8B;AAC9B,kBAAkB;AAClB,gDAAgD;AAChD,+CAA+C;AAC/C,SAAS;AACT,QAAQ;AACR,EAAE;AACF,6DAA6D;AAC7D,oDAAoD;AACpD,oEAAoE;AACpE,iEAAiE;AACjE,8DAA8D;AAC9D,uCAAuC;;;;;;;;;;;;QAC9BA;eAAAA,0CAAoB;;QAEpBC;eAAAA,oDAAyB;;;sCAFG;2CAEK;qBAC5B;qBACA"}

package/dist/src/migrations/1700000000000-CreateBatchMeta.d.ts

@@ -0,0 +1,28 @@
+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 declare class CreateBatchMeta1700000000000 implements MigrationInterface {
+    name: string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}
+//# sourceMappingURL=1700000000000-CreateBatchMeta.d.ts.map

package/dist/src/migrations/1700000000000-CreateBatchMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1700000000000-CreateBatchMeta.d.ts","sourceRoot":"","sources":["../../../src/migrations/1700000000000-CreateBatchMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,4BAA6B,YAAW,kBAAkB;IACrE,IAAI,SAAkC;IAEzB,EAAE,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAkE3C,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAO3D"}

package/dist/src/migrations/1700000000000-CreateBatchMeta.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CreateBatchMeta1700000000000", {
+    enumerable: true,
+    get: function() {
+        return CreateBatchMeta1700000000000;
+    }
+});
+let CreateBatchMeta1700000000000 = class CreateBatchMeta1700000000000 {
+    name = 'CreateBatchMeta1700000000000';
+    async up(queryRunner) {
+        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
+      )
+    `);
+    }
+    async down(queryRunner) {
+        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"`);
+    }
+};
+
+//# sourceMappingURL=1700000000000-CreateBatchMeta.js.map

package/dist/src/migrations/1700000000000-CreateBatchMeta.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/migrations/1700000000000-CreateBatchMeta.ts"],"sourcesContent":["import { MigrationInterface, QueryRunner } from 'typeorm';\n\n/**\n * Creates the six batch meta-tables owned by\n * this package:\n *\n *   - batch_job_instance            (root, unique on (job_name, job_key))\n *   - batch_job_execution           (one per job run, indexed by instance)\n *   - batch_step_execution          (one per step run, indexed by exec)\n *   - batch_job_execution_context   (JSON payload + version, keyed by exec)\n *   - batch_step_execution_context  (JSON payload + version, keyed by step)\n *\n * This migration intentionally uses generic ANSI/PostgreSQL\n * syntax (varchar + text + timestamptz + int). The adapter\n * package's `typeorm-job-repository` is portable across SQLite\n * (test database) and PostgreSQL (production). Users targeting\n * MySQL or another driver should adjust the `down` (and\n * optionally `up`) to match their column types.\n *\n * The `params` column on `batch_job_execution` is a JSON\n * snapshot — stored as `text` to keep the schema portable and\n * always serialized, never queried structurally.\n */\nexport class CreateBatchMeta1700000000000 implements MigrationInterface {\n  name = 'CreateBatchMeta1700000000000';\n\n  public async up(queryRunner: QueryRunner): Promise<void> {\n    await queryRunner.query(`\n      CREATE TABLE IF NOT EXISTS \"batch_job_instance\" (\n        \"id\" varchar(255) PRIMARY KEY,\n        \"job_name\" varchar(255) NOT NULL,\n        \"job_key\" varchar(255) NOT NULL,\n        \"created_at\" timestamptz NOT NULL DEFAULT now(),\n        CONSTRAINT \"batch_job_instance_job_name_job_key_unique\" UNIQUE (\"job_name\", \"job_key\")\n      )\n    `);\n\n    await queryRunner.query(`\n      CREATE TABLE IF NOT EXISTS \"batch_job_execution\" (\n        \"id\" varchar(255) PRIMARY KEY,\n        \"job_instance_id\" varchar(255) NOT NULL,\n        \"status\" varchar(20) NOT NULL,\n        \"start_time\" timestamptz NULL,\n        \"end_time\" timestamptz NULL,\n        \"exit_code\" varchar(255) NOT NULL DEFAULT '',\n        \"exit_message\" text NOT NULL DEFAULT '',\n        \"params\" text NOT NULL DEFAULT '{}'\n      )\n    `);\n    await queryRunner.query(`\n      CREATE INDEX IF NOT EXISTS \"batch_job_execution_job_instance_id_index\"\n      ON \"batch_job_execution\" (\"job_instance_id\")\n    `);\n\n    await queryRunner.query(`\n      CREATE TABLE IF NOT EXISTS \"batch_step_execution\" (\n        \"id\" varchar(255) PRIMARY KEY,\n        \"job_execution_id\" varchar(255) NOT NULL,\n        \"step_name\" varchar(255) NOT NULL,\n        \"status\" varchar(20) NOT NULL,\n        \"read_count\" int NOT NULL DEFAULT 0,\n        \"write_count\" int NOT NULL DEFAULT 0,\n        \"skip_count\" int NOT NULL DEFAULT 0,\n        \"rollback_count\" int NOT NULL DEFAULT 0,\n        \"commit_count\" int NOT NULL DEFAULT 0,\n        \"exit_code\" varchar(255) NOT NULL DEFAULT '',\n        \"exit_message\" text NOT NULL DEFAULT '',\n        \"created_at\" timestamptz NOT NULL DEFAULT now()\n      )\n    `);\n    await queryRunner.query(`\n      CREATE INDEX IF NOT EXISTS \"batch_step_execution_job_execution_id_index\"\n      ON \"batch_step_execution\" (\"job_execution_id\")\n    `);\n\n    await queryRunner.query(`\n      CREATE TABLE IF NOT EXISTS \"batch_job_execution_context\" (\n        \"job_execution_id\" varchar(255) PRIMARY KEY,\n        \"data\" text NOT NULL,\n        \"version\" int NOT NULL DEFAULT 0\n      )\n    `);\n\n    await queryRunner.query(`\n      CREATE TABLE IF NOT EXISTS \"batch_step_execution_context\" (\n        \"step_execution_id\" varchar(255) PRIMARY KEY,\n        \"data\" text NOT NULL,\n        \"version\" int NOT NULL DEFAULT 0\n      )\n    `);\n  }\n\n  public async down(queryRunner: QueryRunner): Promise<void> {\n    await queryRunner.query(`DROP TABLE IF EXISTS \"batch_step_execution_context\"`);\n    await queryRunner.query(`DROP TABLE IF EXISTS \"batch_job_execution_context\"`);\n    await queryRunner.query(`DROP TABLE IF EXISTS \"batch_step_execution\"`);\n    await queryRunner.query(`DROP TABLE IF EXISTS \"batch_job_execution\"`);\n    await queryRunner.query(`DROP TABLE IF EXISTS \"batch_job_instance\"`);\n  }\n}\n"],"names":["CreateBatchMeta1700000000000","name","up","queryRunner","query","down"],"mappings":";;;;+BAuBaA;;;eAAAA;;;AAAN,IAAA,AAAMA,+BAAN,MAAMA;IACXC,OAAO,+BAA+B;IAEtC,MAAaC,GAAGC,WAAwB,EAAiB;QACvD,MAAMA,YAAYC,KAAK,CAAC,CAAC;;;;;;;;IAQzB,CAAC;QAED,MAAMD,YAAYC,KAAK,CAAC,CAAC;;;;;;;;;;;IAWzB,CAAC;QACD,MAAMD,YAAYC,KAAK,CAAC,CAAC;;;IAGzB,CAAC;QAED,MAAMD,YAAYC,KAAK,CAAC,CAAC;;;;;;;;;;;;;;;IAezB,CAAC;QACD,MAAMD,YAAYC,KAAK,CAAC,CAAC;;;IAGzB,CAAC;QAED,MAAMD,YAAYC,KAAK,CAAC,CAAC;;;;;;IAMzB,CAAC;QAED,MAAMD,YAAYC,KAAK,CAAC,CAAC;;;;;;IAMzB,CAAC;IACH;IAEA,MAAaC,KAAKF,WAAwB,EAAiB;QACzD,MAAMA,YAAYC,KAAK,CAAC,CAAC,mDAAmD,CAAC;QAC7E,MAAMD,YAAYC,KAAK,CAAC,CAAC,kDAAkD,CAAC;QAC5E,MAAMD,YAAYC,KAAK,CAAC,CAAC,2CAA2C,CAAC;QACrE,MAAMD,YAAYC,KAAK,CAAC,CAAC,0CAA0C,CAAC;QACpE,MAAMD,YAAYC,KAAK,CAAC,CAAC,yCAAyC,CAAC;IACrE;AACF"}

package/dist/src/repository/typeorm-job-repository.d.ts

@@ -0,0 +1,57 @@
+import { DataSource } from 'typeorm';
+import { JobRepository } from '@nest-batch/core';
+import type { JobInstance, JobExecution, JobExecutionPatch, JobParameters, StepExecution, StepExecutionPatch, ExecutionContext, ExecutionScope, JobInstanceFilter, JobExecutionFilter } from '@nest-batch/core';
+/**
+ * TypeORM 1.0.0-backed `JobRepository`.
+ *
+ * The package is driver-agnostic: the actual `DataSource` is
+ * provided by the `@nest-batch/postgresql` (or future
+ * `@nest-batch/mysql`) driver sibling via the `TypeOrmDriverProvider`
+ * token. The repository itself uses raw SQL via `EntityManager.query`
+ * so the column-shape contract is owned by the driver sibling
+ * (the bundled 6-table migration).
+ *
+ * The contract guarantees:
+ *   - `getOrCreateJobInstance` is race-safe via the (jobName, jobKey)
+ *     unique index.
+ *   - `createExecutionAtomic` runs inside a single transaction that
+ *     (a) idempotently upserts the instance row, (b) acquires a row
+ *     lock with `SELECT ... FOR UPDATE SKIP LOCKED` (PostgreSQL) or
+ *     a plain select (SQLite test driver), and (c) rejects with
+ *     `JobExecutionAlreadyRunningError` if a STARTING/STARTED
+ *     execution already exists.
+ *   - `saveExecutionContext` deep-clones the data and auto-increments
+ *     the version counter when `version` is omitted.
+ *   - `findLatestStepExecution` orders by `created_at` descending.
+ */
+export declare class TypeOrmJobRepository extends JobRepository {
+    private readonly dataSource;
+    constructor(dataSource: DataSource);
+    private em;
+    getOrCreateJobInstance(name: string, jobKey: string): Promise<JobInstance>;
+    createJobExecution(jobInstanceId: string, params: JobParameters): Promise<JobExecution>;
+    createExecutionAtomic(name: string, jobKey: string, params: JobParameters): Promise<JobExecution>;
+    updateJobExecution(executionId: string, patch: JobExecutionPatch): Promise<void>;
+    getJobExecution(executionId: string): Promise<JobExecution | null>;
+    getJobInstance(jobInstanceId: string): Promise<JobInstance | null>;
+    findJobInstances(filter?: JobInstanceFilter): Promise<JobInstance[]>;
+    findJobExecutions(filter?: JobExecutionFilter): Promise<JobExecution[]>;
+    getRunningJobExecution(jobInstanceId: string): Promise<JobExecution | null>;
+    createStepExecution(jobExecutionId: string, stepName: string): Promise<StepExecution>;
+    updateStepExecution(stepExecutionId: string, patch: StepExecutionPatch): Promise<void>;
+    getStepExecution(stepExecutionId: string): Promise<StepExecution | null>;
+    findStepExecutions(jobExecutionId: string): Promise<StepExecution[]>;
+    /**
+     * Find the most recently created step execution for the given
+     * `(jobExecutionId, stepName)` pair, or `null` when none exists.
+     * Insertion order is determined by the `created_at` column; the
+     * primary key is a v4 UUID which is random, so a `id DESC` order
+     * would not correspond to insertion time. The `created_at DESC,
+     * id DESC` secondary order keeps the result stable when two rows
+     * share the same `CURRENT_TIMESTAMP` resolution.
+     */
+    findLatestStepExecution(jobExecutionId: string, stepName: string): Promise<StepExecution | null>;
+    getExecutionContext(scope: ExecutionScope): Promise<ExecutionContext>;
+    saveExecutionContext(scope: ExecutionScope, ctx: ExecutionContext, version?: number): Promise<void>;
+}
+//# sourceMappingURL=typeorm-job-repository.d.ts.map

package/dist/src/repository/typeorm-job-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm-job-repository.d.ts","sourceRoot":"","sources":["../../../src/repository/typeorm-job-repository.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAqB,MAAM,SAAS,CAAC;AACxD,OAAO,EACL,aAAa,EAOd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAyG1B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBACa,oBAAqB,SAAQ,aAAa;IAEpB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAKxE,OAAO,CAAC,EAAE;IAIJ,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAsC1E,kBAAkB,CACtB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC;IAoBlB,qBAAqB,CACzB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC;IA6DlB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBhF,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IASzD,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAWlE,gBAAgB,CAAC,MAAM,GAAE,iBAAsB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAsBxE,iBAAiB,CAAC,MAAM,GAAE,kBAAuB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAgCpF,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAY3E,mBAAmB,CACvB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,aAAa,CAAC;IAWnB,mBAAmB,CACvB,eAAe,EAAE,MAAM,EACvB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,IAAI,CAAC;IAoBV,gBAAgB,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAS/D,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAWnF;;;;;;;;OAQG;IACG,uBAAuB,CAC3B,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAY1B,mBAAmB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA4BrE,oBAAoB,CACxB,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,gBAAgB,EACrB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;CA0CjB"}