@nest-batch/core 0.2.0

package/dist/src/scheduling/batch-scheduled.js

@@ -0,0 +1,170 @@
+"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_SCHEDULED_OPTIONS () {
+        return BATCH_SCHEDULED_OPTIONS;
+    },
+    get BatchScheduled () {
+        return BatchScheduled;
+    },
+    get InvalidBatchScheduledCronError () {
+        return InvalidBatchScheduledCronError;
+    },
+    get InvalidBatchScheduledTimezoneError () {
+        return InvalidBatchScheduledTimezoneError;
+    }
+});
+require("reflect-metadata");
+const _common = require("@nestjs/common");
+const _constants = require("../decorators/constants");
+const BATCH_SCHEDULED_OPTIONS = _constants.BATCH_SCHEDULED_OPTIONS;
+/**
+ * `@BatchScheduled` — cron decorator.
+ *
+ * Stamps `BATCH_SCHEDULED_OPTIONS` metadata onto the decorated method's
+ * function reference (via `@nestjs/common`'s `SetMetadata`, which writes
+ * to `descriptor.value`), so `Reflect.getMetadata(KEY, Job.prototype.run)`
+ * returns the stored shape.
+ *
+ * This is the TDD-RED half of Task 13. It deliberately implements only
+ * the metadata-storing contract — i.e. the 10 happy-path assertions in
+ * `tests/scheduling/batch-scheduled.test.ts` (sections A + B). The
+ * 7 negative-path assertions in sections C + D are the GREEN half
+ * of the contract and land in the next task:
+ *
+ *   1. Cron expression shape validation (5/6 fields, no literal words).
+ *   2. IANA timezone validation (rejects unknown / empty / whitespace).
+ *
+ * The inert-mode flag (section E) is wired up here because it is also
+ * a pure metadata capture — `process.env.BATCH_SCHEDULED_DISABLE` is
+ * read at decoration time and stamped onto the stored shape. The
+ * decorator does NOT install any timer, interval, or scheduler
+ * registration at decoration time; `inert` is a hint the future
+ * runtime scheduler honors when it later walks the class.
+ *
+ * The decorator is metadata-only by design — it does NOT depend on
+ * `cron` (the boundary test from Task 2 still passes — no `cron`
+ * import appears in core).
+ */ // ---------------------------------------------------------------------------
+// Validation helpers
+// ---------------------------------------------------------------------------
+/**
+ * Minimum + maximum number of whitespace-separated fields a valid
+ * cron expression can have. `cronstrue` / Linux
+ * `crontab(5)` all agree on 5 (minute, hour, day-of-month, month,
+ * day-of-week); Quartz-style extensions add a leading seconds field
+ * for 6.
+ */ const CRON_MIN_FIELDS = 5;
+const CRON_MAX_FIELDS = 6;
+/**
+ * Cron-shape check.
+ *
+ * Accepts:
+ *   - 5 fields: `minute hour dom month dow` (Linux crontab style)
+ *   - 6 fields: `second minute hour dom month dow` (extended cron style)
+ *
+ * Each field is `\S+` (one or more non-whitespace tokens, no empty
+ * fields). The trailing `\S+$` is the final field; the leading
+ * `(\S+\s+){4,5}` captures the preceding 4 or 5 fields separated by
+ * a single whitespace run.
+ *
+ * This is a shape check, not a semantic one — `99 99 99 99 99` still
+ * passes the regex. The runtime scheduler (in `@nest-batch/bullmq`)
+ * is the layer that handles semantic validation via `cron-parser`.
+ * The shape check exists so the decorator fails fast on
+ * unambiguously-wrong input (empty string, too few / too many
+ * fields, literal English words).
+ */ const CRON_SHAPE = /^(\S+\s+){4,5}\S+$/;
+/**
+ * IANA timezone validation.
+ *
+ * The platform's `Intl.DateTimeFormat` is the canonical, no-dep
+ * source of truth for valid IANA zone identifiers: it throws a
+ * `RangeError` for unknown zones. We use it inside a `try/catch` and
+ * normalise the result to a boolean so the decorator's failure mode
+ * is a deterministic `Error` (not a `RangeError` leaking out).
+ *
+ * Reference: https://tc39.es/ecma402/#sec-intl-datetimeformat-constructor
+ */ function isValidIanaTimezone(tz) {
+    try {
+        new Intl.DateTimeFormat(undefined, {
+            timeZone: tz
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Validate a cron expression. Throws a deterministic
+ * `InvalidBatchScheduledCronError` whose `.message` embeds the
+ * invalid value verbatim so log lines and test assertions can pin
+ * the error to a specific input.
+ */ function assertValidCron(cronExpression) {
+    // Type guard: a non-string value would have already broken
+    // SetMetadata, but checking here keeps the helper standalone.
+    if (typeof cronExpression !== 'string' || cronExpression.length === 0) {
+        throw new InvalidBatchScheduledCronError(cronExpression, 'empty');
+    }
+    if (!CRON_SHAPE.test(cronExpression.trim())) {
+        const fieldCount = cronExpression.trim().split(/\s+/).length;
+        const reason = fieldCount < CRON_MIN_FIELDS ? `fewer than ${CRON_MIN_FIELDS} fields` : fieldCount > CRON_MAX_FIELDS ? `more than ${CRON_MAX_FIELDS} fields` : 'not a valid cron expression';
+        throw new InvalidBatchScheduledCronError(cronExpression, reason);
+    }
+}
+/**
+ * Validate a timezone string. Throws a deterministic
+ * `InvalidBatchScheduledTimezoneError` whose `.message` embeds the
+ * invalid value verbatim.
+ */ function assertValidTimezone(tz) {
+    if (typeof tz !== 'string' || tz.trim().length === 0) {
+        throw new InvalidBatchScheduledTimezoneError(tz, 'empty');
+    }
+    if (!isValidIanaTimezone(tz)) {
+        throw new InvalidBatchScheduledTimezoneError(tz, 'not a valid IANA timezone');
+    }
+}
+let InvalidBatchScheduledCronError = class InvalidBatchScheduledCronError extends Error {
+    cron;
+    reason;
+    constructor(cron, reason){
+        super(`[BatchScheduled] invalid cron expression "${cron}": ${reason}. ` + `Expected ${CRON_MIN_FIELDS} (Linux crontab) or ${CRON_MAX_FIELDS} (extended cron) ` + `whitespace-separated fields.`);
+        this.name = 'InvalidBatchScheduledCronError';
+        this.cron = cron;
+        this.reason = reason;
+    }
+};
+let InvalidBatchScheduledTimezoneError = class InvalidBatchScheduledTimezoneError extends Error {
+    timezone;
+    reason;
+    constructor(timezone, reason){
+        super(`[BatchScheduled] invalid timezone "${timezone}": ${reason}. ` + `Expected a valid IANA zone identifier (e.g. "UTC", "Asia/Seoul", "America/New_York").`);
+        this.name = 'InvalidBatchScheduledTimezoneError';
+        this.timezone = timezone;
+        this.reason = reason;
+    }
+};
+function BatchScheduled(cronExpression, options) {
+    // 1. Validate inputs at decoration time. The decorator is
+    //    synchronous and metadata-only; the validation runs BEFORE
+    //    `SetMetadata(...)` is called so a bad input never reaches
+    //    the registry.
+    assertValidCron(cronExpression);
+    assertValidTimezone(options.timezone);
+    const meta = {
+        cron: cronExpression,
+        options,
+        inert: process.env.BATCH_SCHEDULED_DISABLE === '1'
+    };
+    return (0, _common.SetMetadata)(BATCH_SCHEDULED_OPTIONS, meta);
+}
+
+//# sourceMappingURL=batch-scheduled.js.map

package/dist/src/scheduling/batch-scheduled.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/scheduling/batch-scheduled.ts"],"sourcesContent":["import 'reflect-metadata';\nimport { SetMetadata } from '@nestjs/common';\n\nimport { BATCH_SCHEDULED_OPTIONS as SCHEDULED_KEY } from '../decorators/constants';\n\nexport const BATCH_SCHEDULED_OPTIONS = SCHEDULED_KEY;\n\n/**\n * Overlap policies for cron-scheduled jobs:\n *\n * - `'skip'`     — drop the new tick if the previous run is still in flight.\n * - `'queue'`    — buffer the new tick and start it after the current one ends.\n * - `'parallel'` — start the new tick alongside the current one.\n *\n * The runtime scheduler (the future `@nest-batch/bullmq` cron strategy)\n * reads this value off the stored metadata and applies the policy at\n * dispatch time. The decorator itself MUST NOT silently default the\n * policy to `'skip'` on the user's behalf — leaving it `undefined` here\n * is the contract: the runtime applies the default.\n */\nexport type BatchOverlapPolicy = 'skip' | 'queue' | 'parallel';\n\n/**\n * Decorator-facing options for `@BatchScheduled`.\n *\n * - `name`     — required, unique per job (used as the scheduling key).\n * - `timezone` — required, IANA zone (e.g. `'UTC'`, `'Asia/Seoul'`).\n * - `overlap`  — optional, see `BatchOverlapPolicy`. Default applied at\n *                runtime, never silently here.\n * - `startAt`  — optional, absolute lower bound. Preserved by reference.\n * - `endAt`    — optional, absolute upper bound. Preserved by reference.\n * - `inert`    — optional, hints the runtime scheduler to skip actual\n *                registration. The decorator stamps this by reading\n *                `process.env.BATCH_SCHEDULED_DISABLE` at decoration time\n *                so the runtime never has to re-evaluate the env.\n */\nexport interface BatchScheduledOptions {\n  name: string;\n  timezone: string;\n  overlap?: BatchOverlapPolicy;\n  startAt?: Date;\n  endAt?: Date;\n  inert?: boolean;\n}\n\n/**\n * The shape stored under the `BATCH_SCHEDULED_OPTIONS` metadata key on\n * the decorated method function. The runtime scheduler (the future\n * `@nest-batch/bullmq` cron strategy) reads this verbatim to register\n * the job with the underlying scheduler.\n *\n * Note: `inert` lives at the top level (not inside `options`) on\n * purpose. It is a *runtime* flag captured at decoration time from\n * `process.env.BATCH_SCHEDULED_DISABLE`; it is not a user-facing\n * knob in `BatchScheduledOptions`. (The `inert?: boolean` slot on\n * `BatchScheduledOptions` is the user-facing counterpart — see the\n * GREEN half of Task 13 to wire it up.)\n */\nexport interface BatchScheduledMetadata {\n  cron: string;\n  options: BatchScheduledOptions;\n  inert: boolean;\n}\n\n/**\n * `@BatchScheduled` — cron decorator.\n *\n * Stamps `BATCH_SCHEDULED_OPTIONS` metadata onto the decorated method's\n * function reference (via `@nestjs/common`'s `SetMetadata`, which writes\n * to `descriptor.value`), so `Reflect.getMetadata(KEY, Job.prototype.run)`\n * returns the stored shape.\n *\n * This is the TDD-RED half of Task 13. It deliberately implements only\n * the metadata-storing contract — i.e. the 10 happy-path assertions in\n * `tests/scheduling/batch-scheduled.test.ts` (sections A + B). The\n * 7 negative-path assertions in sections C + D are the GREEN half\n * of the contract and land in the next task:\n *\n *   1. Cron expression shape validation (5/6 fields, no literal words).\n *   2. IANA timezone validation (rejects unknown / empty / whitespace).\n *\n * The inert-mode flag (section E) is wired up here because it is also\n * a pure metadata capture — `process.env.BATCH_SCHEDULED_DISABLE` is\n * read at decoration time and stamped onto the stored shape. The\n * decorator does NOT install any timer, interval, or scheduler\n * registration at decoration time; `inert` is a hint the future\n * runtime scheduler honors when it later walks the class.\n *\n * The decorator is metadata-only by design — it does NOT depend on\n * `cron` (the boundary test from Task 2 still passes — no `cron`\n * import appears in core).\n */\n// ---------------------------------------------------------------------------\n// Validation helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Minimum + maximum number of whitespace-separated fields a valid\n * cron expression can have. `cronstrue` / Linux\n * `crontab(5)` all agree on 5 (minute, hour, day-of-month, month,\n * day-of-week); Quartz-style extensions add a leading seconds field\n * for 6.\n */\nconst CRON_MIN_FIELDS = 5;\nconst CRON_MAX_FIELDS = 6;\n\n/**\n * Cron-shape check.\n *\n * Accepts:\n *   - 5 fields: `minute hour dom month dow` (Linux crontab style)\n *   - 6 fields: `second minute hour dom month dow` (extended cron style)\n *\n * Each field is `\\S+` (one or more non-whitespace tokens, no empty\n * fields). The trailing `\\S+$` is the final field; the leading\n * `(\\S+\\s+){4,5}` captures the preceding 4 or 5 fields separated by\n * a single whitespace run.\n *\n * This is a shape check, not a semantic one — `99 99 99 99 99` still\n * passes the regex. The runtime scheduler (in `@nest-batch/bullmq`)\n * is the layer that handles semantic validation via `cron-parser`.\n * The shape check exists so the decorator fails fast on\n * unambiguously-wrong input (empty string, too few / too many\n * fields, literal English words).\n */\nconst CRON_SHAPE = /^(\\S+\\s+){4,5}\\S+$/;\n\n/**\n * IANA timezone validation.\n *\n * The platform's `Intl.DateTimeFormat` is the canonical, no-dep\n * source of truth for valid IANA zone identifiers: it throws a\n * `RangeError` for unknown zones. We use it inside a `try/catch` and\n * normalise the result to a boolean so the decorator's failure mode\n * is a deterministic `Error` (not a `RangeError` leaking out).\n *\n * Reference: https://tc39.es/ecma402/#sec-intl-datetimeformat-constructor\n */\nfunction isValidIanaTimezone(tz: string): boolean {\n  try {\n    new Intl.DateTimeFormat(undefined, { timeZone: tz });\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validate a cron expression. Throws a deterministic\n * `InvalidBatchScheduledCronError` whose `.message` embeds the\n * invalid value verbatim so log lines and test assertions can pin\n * the error to a specific input.\n */\nfunction assertValidCron(cronExpression: string): void {\n  // Type guard: a non-string value would have already broken\n  // SetMetadata, but checking here keeps the helper standalone.\n  if (typeof cronExpression !== 'string' || cronExpression.length === 0) {\n    throw new InvalidBatchScheduledCronError(cronExpression, 'empty');\n  }\n  if (!CRON_SHAPE.test(cronExpression.trim())) {\n    const fieldCount = cronExpression.trim().split(/\\s+/).length;\n    const reason =\n      fieldCount < CRON_MIN_FIELDS\n        ? `fewer than ${CRON_MIN_FIELDS} fields`\n        : fieldCount > CRON_MAX_FIELDS\n          ? `more than ${CRON_MAX_FIELDS} fields`\n          : 'not a valid cron expression';\n    throw new InvalidBatchScheduledCronError(cronExpression, reason);\n  }\n}\n\n/**\n * Validate a timezone string. Throws a deterministic\n * `InvalidBatchScheduledTimezoneError` whose `.message` embeds the\n * invalid value verbatim.\n */\nfunction assertValidTimezone(tz: string): void {\n  if (typeof tz !== 'string' || tz.trim().length === 0) {\n    throw new InvalidBatchScheduledTimezoneError(tz, 'empty');\n  }\n  if (!isValidIanaTimezone(tz)) {\n    throw new InvalidBatchScheduledTimezoneError(tz, 'not a valid IANA timezone');\n  }\n}\n\n/**\n * Thrown by `@BatchScheduled` when the cron expression fails the\n * shape check (5/6 fields, non-whitespace tokens). The `.message`\n * includes the invalid value and the failure reason so the error\n * is greppable in logs and pinned in test assertions.\n *\n * Exported from the module barrel so adapter packages (e.g. the\n * BullMQ runtime) can `instanceof`-check it without reaching into\n * the decorator's internal helper.\n */\nexport class InvalidBatchScheduledCronError extends Error {\n  readonly cron: string;\n  readonly reason: string;\n\n  constructor(cron: string, reason: string) {\n    super(\n      `[BatchScheduled] invalid cron expression \"${cron}\": ${reason}. ` +\n        `Expected ${CRON_MIN_FIELDS} (Linux crontab) or ${CRON_MAX_FIELDS} (extended cron) ` +\n        `whitespace-separated fields.`,\n    );\n    this.name = 'InvalidBatchScheduledCronError';\n    this.cron = cron;\n    this.reason = reason;\n  }\n}\n\n/**\n * Thrown by `@BatchScheduled` when the IANA timezone fails the\n * platform check. The `.message` embeds the invalid value and the\n * failure reason.\n *\n * Exported from the module barrel so adapter packages can\n * `instanceof`-check it without reaching into the decorator's\n * internal helper.\n */\nexport class InvalidBatchScheduledTimezoneError extends Error {\n  readonly timezone: string;\n  readonly reason: string;\n\n  constructor(timezone: string, reason: string) {\n    super(\n      `[BatchScheduled] invalid timezone \"${timezone}\": ${reason}. ` +\n        `Expected a valid IANA zone identifier (e.g. \"UTC\", \"Asia/Seoul\", \"America/New_York\").`,\n    );\n    this.name = 'InvalidBatchScheduledTimezoneError';\n    this.timezone = timezone;\n    this.reason = reason;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Decorator\n// ---------------------------------------------------------------------------\n\nexport function BatchScheduled(\n  cronExpression: string,\n  options: BatchScheduledOptions,\n): MethodDecorator {\n  // 1. Validate inputs at decoration time. The decorator is\n  //    synchronous and metadata-only; the validation runs BEFORE\n  //    `SetMetadata(...)` is called so a bad input never reaches\n  //    the registry.\n  assertValidCron(cronExpression);\n  assertValidTimezone(options.timezone);\n\n  const meta: BatchScheduledMetadata = {\n    cron: cronExpression,\n    options,\n    inert: process.env.BATCH_SCHEDULED_DISABLE === '1',\n  };\n  return SetMetadata(BATCH_SCHEDULED_OPTIONS, meta);\n}\n"],"names":["BATCH_SCHEDULED_OPTIONS","BatchScheduled","InvalidBatchScheduledCronError","InvalidBatchScheduledTimezoneError","SCHEDULED_KEY","CRON_MIN_FIELDS","CRON_MAX_FIELDS","CRON_SHAPE","isValidIanaTimezone","tz","Intl","DateTimeFormat","undefined","timeZone","assertValidCron","cronExpression","length","test","trim","fieldCount","split","reason","assertValidTimezone","Error","cron","name","timezone","options","meta","inert","process","env","BATCH_SCHEDULED_DISABLE","SetMetadata"],"mappings":";;;;;;;;;;;QAKaA;eAAAA;;QA0OGC;eAAAA;;QA5CHC;eAAAA;;QAyBAC;eAAAA;;;QA5NN;wBACqB;2BAE6B;AAElD,MAAMH,0BAA0BI,kCAAa;AA2DpD;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BC,GACD,8EAA8E;AAC9E,qBAAqB;AACrB,8EAA8E;AAE9E;;;;;;CAMC,GACD,MAAMC,kBAAkB;AACxB,MAAMC,kBAAkB;AAExB;;;;;;;;;;;;;;;;;;CAkBC,GACD,MAAMC,aAAa;AAEnB;;;;;;;;;;CAUC,GACD,SAASC,oBAAoBC,EAAU;IACrC,IAAI;QACF,IAAIC,KAAKC,cAAc,CAACC,WAAW;YAAEC,UAAUJ;QAAG;QAClD,OAAO;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF;AAEA;;;;;CAKC,GACD,SAASK,gBAAgBC,cAAsB;IAC7C,2DAA2D;IAC3D,8DAA8D;IAC9D,IAAI,OAAOA,mBAAmB,YAAYA,eAAeC,MAAM,KAAK,GAAG;QACrE,MAAM,IAAId,+BAA+Ba,gBAAgB;IAC3D;IACA,IAAI,CAACR,WAAWU,IAAI,CAACF,eAAeG,IAAI,KAAK;QAC3C,MAAMC,aAAaJ,eAAeG,IAAI,GAAGE,KAAK,CAAC,OAAOJ,MAAM;QAC5D,MAAMK,SACJF,aAAad,kBACT,CAAC,WAAW,EAAEA,gBAAgB,OAAO,CAAC,GACtCc,aAAab,kBACX,CAAC,UAAU,EAAEA,gBAAgB,OAAO,CAAC,GACrC;QACR,MAAM,IAAIJ,+BAA+Ba,gBAAgBM;IAC3D;AACF;AAEA;;;;CAIC,GACD,SAASC,oBAAoBb,EAAU;IACrC,IAAI,OAAOA,OAAO,YAAYA,GAAGS,IAAI,GAAGF,MAAM,KAAK,GAAG;QACpD,MAAM,IAAIb,mCAAmCM,IAAI;IACnD;IACA,IAAI,CAACD,oBAAoBC,KAAK;QAC5B,MAAM,IAAIN,mCAAmCM,IAAI;IACnD;AACF;AAYO,IAAA,AAAMP,iCAAN,MAAMA,uCAAuCqB;IACzCC,KAAa;IACbH,OAAe;IAExB,YAAYG,IAAY,EAAEH,MAAc,CAAE;QACxC,KAAK,CACH,CAAC,0CAA0C,EAAEG,KAAK,GAAG,EAAEH,OAAO,EAAE,CAAC,GAC/D,CAAC,SAAS,EAAEhB,gBAAgB,oBAAoB,EAAEC,gBAAgB,iBAAiB,CAAC,GACpF,CAAC,4BAA4B,CAAC;QAElC,IAAI,CAACmB,IAAI,GAAG;QACZ,IAAI,CAACD,IAAI,GAAGA;QACZ,IAAI,CAACH,MAAM,GAAGA;IAChB;AACF;AAWO,IAAA,AAAMlB,qCAAN,MAAMA,2CAA2CoB;IAC7CG,SAAiB;IACjBL,OAAe;IAExB,YAAYK,QAAgB,EAAEL,MAAc,CAAE;QAC5C,KAAK,CACH,CAAC,mCAAmC,EAAEK,SAAS,GAAG,EAAEL,OAAO,EAAE,CAAC,GAC5D,CAAC,qFAAqF,CAAC;QAE3F,IAAI,CAACI,IAAI,GAAG;QACZ,IAAI,CAACC,QAAQ,GAAGA;QAChB,IAAI,CAACL,MAAM,GAAGA;IAChB;AACF;AAMO,SAASpB,eACdc,cAAsB,EACtBY,OAA8B;IAE9B,0DAA0D;IAC1D,+DAA+D;IAC/D,+DAA+D;IAC/D,mBAAmB;IACnBb,gBAAgBC;IAChBO,oBAAoBK,QAAQD,QAAQ;IAEpC,MAAME,OAA+B;QACnCJ,MAAMT;QACNY;QACAE,OAAOC,QAAQC,GAAG,CAACC,uBAAuB,KAAK;IACjD;IACA,OAAOC,IAAAA,mBAAW,EAACjC,yBAAyB4B;AAC9C"}

package/dist/src/transaction/in-memory-transaction-manager.d.ts

@@ -0,0 +1,16 @@
+import { TransactionContext, TransactionManager } from '../core/transaction/transaction-manager';
+export interface InMemoryTransactionContext extends TransactionContext {
+    readonly isActive: true;
+    readonly id: string;
+}
+/**
+ * No-op TransactionManager for the in-memory adapter and for tests.
+ * Calls `fn(ctx)` directly without any real transactional semantics.
+ *
+ * For real DB transactions, use a MikroORM/SQL adapter implementation
+ * (e.g., `MikroORMTransactionManager`).
+ */
+export declare class InMemoryTransactionManager extends TransactionManager {
+    withTransaction<T>(fn: (ctx: InMemoryTransactionContext) => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=in-memory-transaction-manager.d.ts.map

package/dist/src/transaction/in-memory-transaction-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-transaction-manager.d.ts","sourceRoot":"","sources":["../../../src/transaction/in-memory-transaction-manager.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAEjG,MAAM,WAAW,0BAA2B,SAAQ,kBAAkB;IACpE,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;GAMG;AACH,qBACa,0BAA2B,SAAQ,kBAAkB;IAC1D,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,0BAA0B,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAI1F"}

package/dist/src/transaction/in-memory-transaction-manager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "InMemoryTransactionManager", {
+    enumerable: true,
+    get: function() {
+        return InMemoryTransactionManager;
+    }
+});
+const _common = require("@nestjs/common");
+const _crypto = require("crypto");
+const _transactionmanager = require("../core/transaction/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 InMemoryTransactionManager = class InMemoryTransactionManager extends _transactionmanager.TransactionManager {
+    async withTransaction(fn) {
+        const ctx = {
+            isActive: true,
+            id: (0, _crypto.randomUUID)()
+        };
+        return fn(ctx);
+    }
+};
+InMemoryTransactionManager = _ts_decorate([
+    (0, _common.Injectable)()
+], InMemoryTransactionManager);
+
+//# sourceMappingURL=in-memory-transaction-manager.js.map

package/dist/src/transaction/in-memory-transaction-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/transaction/in-memory-transaction-manager.ts"],"sourcesContent":["import { Injectable } from '@nestjs/common';\nimport { randomUUID } from 'crypto';\nimport { TransactionContext, TransactionManager } from '../core/transaction/transaction-manager';\n\nexport interface InMemoryTransactionContext extends TransactionContext {\n  readonly isActive: true;\n  readonly id: string;\n}\n\n/**\n * No-op TransactionManager for the in-memory adapter and for tests.\n * Calls `fn(ctx)` directly without any real transactional semantics.\n *\n * For real DB transactions, use a MikroORM/SQL adapter implementation\n * (e.g., `MikroORMTransactionManager`).\n */\n@Injectable()\nexport class InMemoryTransactionManager extends TransactionManager {\n  async withTransaction<T>(fn: (ctx: InMemoryTransactionContext) => Promise<T>): Promise<T> {\n    const ctx: InMemoryTransactionContext = { isActive: true, id: randomUUID() };\n    return fn(ctx);\n  }\n}\n"],"names":["InMemoryTransactionManager","TransactionManager","withTransaction","fn","ctx","isActive","id","randomUUID"],"mappings":";;;;+BAiBaA;;;eAAAA;;;wBAjBc;wBACA;oCAC4B;;;;;;;AAehD,IAAA,AAAMA,6BAAN,MAAMA,mCAAmCC,sCAAkB;IAChE,MAAMC,gBAAmBC,EAAmD,EAAc;QACxF,MAAMC,MAAkC;YAAEC,UAAU;YAAMC,IAAIC,IAAAA,kBAAU;QAAG;QAC3E,OAAOJ,GAAGC;IACZ;AACF"}

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

@@ -0,0 +1,2 @@
+export * from './in-memory-transaction-manager';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/src/transaction/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./in-memory-transaction-manager"), 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/transaction/index.js.map

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

package/dist/tests/contracts/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared contract test suites for `@nest-batch/core` adapter packages.
+ *
+ * These suites are intentionally ORM-agnostic: they reference only the
+ * public core interfaces (`IJobRepository`, `TransactionManager`) and
+ * value types. Each suite is exposed as a function that takes a factory
+ * returning a fresh `(repo, tx)` pair per test.
+ *
+ * Usage from a future adapter package (e.g. `@nest-batch/mikro-orm`):
+ *
+ *   import { runJobRepositoryContract } from '@nest-batch/core/test-contracts';
+ *   import { MikroORMJobRepository } from '../mikroorm-job-repository';
+ *   import { MikroORMTransactionManager } from '../mikroorm-transaction-manager';
+ *
+ *   runJobRepositoryContract(
+ *     {
+ *       create: () => ({
+ *         repo: new MikroORMJobRepository(em),
+ *         tx: new MikroORMTransactionManager(em),
+ *       }),
+ *     },
+ *     'MikroORM',
+ *   );
+ */
+export { runJobRepositoryContract, type JobRepositoryContractFactory, } from './job-repository.contract';
+//# sourceMappingURL=index.d.ts.map

package/dist/tests/contracts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../tests/contracts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EACL,wBAAwB,EACxB,KAAK,4BAA4B,GAClC,MAAM,2BAA2B,CAAC"}

package/dist/tests/contracts/index.js

@@ -0,0 +1,37 @@
+/**
+ * Shared contract test suites for `@nest-batch/core` adapter packages.
+ *
+ * These suites are intentionally ORM-agnostic: they reference only the
+ * public core interfaces (`IJobRepository`, `TransactionManager`) and
+ * value types. Each suite is exposed as a function that takes a factory
+ * returning a fresh `(repo, tx)` pair per test.
+ *
+ * Usage from a future adapter package (e.g. `@nest-batch/mikro-orm`):
+ *
+ *   import { runJobRepositoryContract } from '@nest-batch/core/test-contracts';
+ *   import { MikroORMJobRepository } from '../mikroorm-job-repository';
+ *   import { MikroORMTransactionManager } from '../mikroorm-transaction-manager';
+ *
+ *   runJobRepositoryContract(
+ *     {
+ *       create: () => ({
+ *         repo: new MikroORMJobRepository(em),
+ *         tx: new MikroORMTransactionManager(em),
+ *       }),
+ *     },
+ *     'MikroORM',
+ *   );
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runJobRepositoryContract", {
+    enumerable: true,
+    get: function() {
+        return _jobrepositorycontract.runJobRepositoryContract;
+    }
+});
+const _jobrepositorycontract = require("./job-repository.contract");
+
+
+//# sourceMappingURL=index.js.map

package/dist/tests/contracts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../tests/contracts/index.ts"],"names":["runJobRepositoryContract"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;CAuBC;;;;+BAECA;;;eAAAA,+CAAwB;;;uCAEnB","file":"index.js","sourcesContent":["/**\n * Shared contract test suites for `@nest-batch/core` adapter packages.\n *\n * These suites are intentionally ORM-agnostic: they reference only the\n * public core interfaces (`IJobRepository`, `TransactionManager`) and\n * value types. Each suite is exposed as a function that takes a factory\n * returning a fresh `(repo, tx)` pair per test.\n *\n * Usage from a future adapter package (e.g. `@nest-batch/mikro-orm`):\n *\n *   import { runJobRepositoryContract } from '@nest-batch/core/test-contracts';\n *   import { MikroORMJobRepository } from '../mikroorm-job-repository';\n *   import { MikroORMTransactionManager } from '../mikroorm-transaction-manager';\n *\n *   runJobRepositoryContract(\n *     {\n *       create: () => ({\n *         repo: new MikroORMJobRepository(em),\n *         tx: new MikroORMTransactionManager(em),\n *       }),\n *     },\n *     'MikroORM',\n *   );\n */\nexport {\n  runJobRepositoryContract,\n  type JobRepositoryContractFactory,\n} from './job-repository.contract';\n"]}

package/dist/tests/contracts/job-repository.contract.d.ts

@@ -0,0 +1,46 @@
+import { type IJobRepository } from '@nest-batch/core';
+import { TransactionManager } from '@nest-batch/core';
+/**
+ * A factory that returns a fresh `JobRepository` + `TransactionManager`
+ * pair per call.
+ *
+ * Every contract test calls this in `beforeEach` to guarantee isolation
+ * between cases. Implementations that need a per-test transaction
+ * manager, a fresh in-memory store, or a per-test DB transaction
+ * rollback can plug that in here.
+ */
+export interface JobRepositoryContractFactory {
+    create(): {
+        repo: IJobRepository;
+        tx: TransactionManager;
+    };
+}
+/**
+ * Shared `JobRepository` + `TransactionManager` contract suite.
+ *
+ * Every implementation of the batch core repository/transaction contract
+ * — in-memory, `@nest-batch/mikro-orm`, `@nest-batch/typeorm`, future
+ * adapters — must pass this suite. The contract covers:
+ *
+ *  - Happy-path lifecycle: getOrCreateJobInstance → createExecutionAtomic
+ *    → status updates → step execution lifecycle.
+ *  - ExecutionContext save/load roundtrip (the restart-checkpoint
+ *    payload path).
+ *  - `findLatestStepExecution` returning the latest matching row (the
+ *    restart-resume lookup), and only that step name.
+ *  - `TransactionManager.withTransaction` wrapping + propagation of
+ *    errors and resolved values.
+ *  - Negative: a duplicate active execution is rejected
+ *    (`JobExecutionAlreadyRunningError`).
+ *  - Concurrency: when N callers race `createExecutionAtomic` against
+ *    the same `(name, jobKey)`, exactly one wins and the others reject.
+ *    This is the in-memory stand-in for PostgreSQL's
+ *    `FOR UPDATE SKIP LOCKED` semantics.
+ *  - Idempotency: a second launch is allowed after the prior execution
+ *    is no longer `STARTING`/`STARTED` (e.g. `COMPLETED`).
+ *
+ * The contract is intentionally decoupled from any concrete ORM entity
+ * class: only the public interfaces and value types are referenced.
+ */
+export declare function runJobRepositoryContract(factory: JobRepositoryContractFactory, implName: string): void;
+//# sourceMappingURL=job-repository.contract.d.ts.map

package/dist/tests/contracts/job-repository.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-repository.contract.d.ts","sourceRoot":"","sources":["../../../tests/contracts/job-repository.contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAStD;;;;;;;;GAQG;AACH,MAAM,WAAW,4BAA4B;IAC3C,MAAM,IAAI;QAAE,IAAI,EAAE,cAAc,CAAC;QAAC,EAAE,EAAE,kBAAkB,CAAA;KAAE,CAAC;CAC5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,4BAA4B,EACrC,QAAQ,EAAE,MAAM,GACf,IAAI,CAigBN"}