@dudousxd/nestjs-durable-store-mikro-orm 0.26.0 → 0.27.1

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import * as _mikro_orm_core from '@mikro-orm/core';
 import { EntityRepository, EntityRepositoryType, EntitySchema, MikroORM } from '@mikro-orm/core';
-import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, SignalWaiter } from '@dudousxd/nestjs-durable-core';
 
 /**
  * Custom repositories for the durable entities, so a host app can `@InjectRepository`/inject a
@@ -29,6 +29,8 @@ declare class BufferedSignalRepository extends EntityRepository<BufferedSignalEn
 }
 declare class BufferedEventRepository extends EntityRepository<BufferedEventEntity> {
 }
+declare class ScheduleRepository extends EntityRepository<ScheduleEntity> {
+}
 
 /**
  * How property names map to physical column names. The durable tables are adapter-agnostic: a run
@@ -121,6 +123,22 @@ declare class BufferedEventEntity {
     payload?: unknown;
     publishedAt: Date;
 }
+/** A persisted schedule (`engine.schedules`). `spec`/`state` are engine-owned JSON documents. */
+declare class ScheduleEntity {
+    [EntityRepositoryType]?: ScheduleRepository;
+    id: string;
+    namespace: string;
+    workflow: string;
+    paused: boolean;
+    /** Epoch ms as a `bigint` column — exact, so `updateSchedule`'s compare-and-set can't be defeated
+     *  by a DATETIME's truncated milliseconds. Drivers may hand it back as a string. */
+    nextFireAt?: number | string | bigint | null;
+    tags?: string[] | null;
+    spec: Record<string, unknown>;
+    state: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
 declare function durableEntities(options?: {
     naming?: DurableColumnNaming;
 }): EntitySchema[];
@@ -167,13 +185,15 @@ declare class MikroOrmStateStore implements StateStore {
      */
     private fork;
     ensureSchema(): Promise<void>;
+    tryAdmitSingleton(runId: string, tag: string, workflow: string, limit: number, retryWakeAt?: number): Promise<boolean>;
     createRun(run: WorkflowRun): Promise<void>;
-    updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
+    updateRun(runId: string, inputPatch: Partial<WorkflowRun>): Promise<void>;
     /** Rewrite a run's normalized attribute rows: delete the old set, insert the current one. Mirrors
      *  the in-memory store's reindex so the side-table always reflects the run's live searchAttributes. */
     private reindexAttributes;
     getRun(runId: string): Promise<WorkflowRun | null>;
     deleteRun(runId: string): Promise<void>;
+    deleteRuns(runIds: string[]): Promise<void>;
     pruneTerminalRuns(policy: RetentionPolicy, nowMs: number, limit: number): Promise<number>;
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
@@ -199,6 +219,7 @@ declare class MikroOrmStateStore implements StateStore {
     /** `tags LIKE '%"etl"%'` — the quoted token, so `etl` doesn't match `etl-foo`. See the note in
      *  {@link listRuns} for why this is raw SQL rather than a MikroORM condition. */
     private tagLikeSql;
+    countRuns(query: Omit<RunQuery, 'limit' | 'offset'>): Promise<number>;
     /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
      *  console can show whole-set counts next to a bounded page instead of downloading every run to
      *  count them in the browser. */
@@ -257,6 +278,13 @@ declare class MikroOrmStateStore implements StateStore {
     private jsonAsText;
     /** Quote an identifier per the active SQL driver (MySQL/MariaDB backtick, others double-quote). */
     private idQuote;
+    saveSchedule(record: ScheduleRecord): Promise<void>;
+    getSchedule(id: string): Promise<ScheduleRecord | null>;
+    /** One conditional `nativeUpdate`: the compare-and-set on `next_fire_at` (an exact bigint) is a
+     *  single statement. */
+    updateSchedule(id: string, patch: Partial<Omit<ScheduleRecord, 'id' | 'createdAt'>>, expectedNextFireAt?: number | null): Promise<boolean>;
+    deleteSchedule(id: string): Promise<boolean>;
+    listSchedules(query: ScheduleQuery): Promise<ScheduleRecord[]>;
     listCheckpoints(runId: string): Promise<StepCheckpoint[]>;
     getLatestCheckpointByName(runId: string, name: string): Promise<StepCheckpoint | undefined>;
     listCheckpointsByNamePrefix(runId: string, prefixes: string[]): Promise<StepCheckpoint[]>;
@@ -327,4 +355,4 @@ declare function durableManagedTables(): string[];
  */
 declare function ensureMikroOrmDurableSchema(orm: MikroORM): Promise<void>;
 
-export { BufferedEventEntity, BufferedEventRepository, BufferedSignalEntity, BufferedSignalRepository, type DurableColumnNaming, ENTITIES, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, RunAttributeRepository, SignalWaiterEntity, SignalWaiterRepository, StepCheckpointEntity, StepCheckpointRepository, WorkflowRunEntity, WorkflowRunRepository, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema };
+export { BufferedEventEntity, BufferedEventRepository, BufferedSignalEntity, BufferedSignalRepository, type DurableColumnNaming, ENTITIES, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, RunAttributeRepository, ScheduleEntity, ScheduleRepository, SignalWaiterEntity, SignalWaiterRepository, StepCheckpointEntity, StepCheckpointRepository, WorkflowRunEntity, WorkflowRunRepository, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as _mikro_orm_core from '@mikro-orm/core';
 import { EntityRepository, EntityRepositoryType, EntitySchema, MikroORM } from '@mikro-orm/core';
-import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+import { StepKind, RunStatus, StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, SignalWaiter } from '@dudousxd/nestjs-durable-core';
 
 /**
  * Custom repositories for the durable entities, so a host app can `@InjectRepository`/inject a
@@ -29,6 +29,8 @@ declare class BufferedSignalRepository extends EntityRepository<BufferedSignalEn
 }
 declare class BufferedEventRepository extends EntityRepository<BufferedEventEntity> {
 }
+declare class ScheduleRepository extends EntityRepository<ScheduleEntity> {
+}
 
 /**
  * How property names map to physical column names. The durable tables are adapter-agnostic: a run
@@ -121,6 +123,22 @@ declare class BufferedEventEntity {
     payload?: unknown;
     publishedAt: Date;
 }
+/** A persisted schedule (`engine.schedules`). `spec`/`state` are engine-owned JSON documents. */
+declare class ScheduleEntity {
+    [EntityRepositoryType]?: ScheduleRepository;
+    id: string;
+    namespace: string;
+    workflow: string;
+    paused: boolean;
+    /** Epoch ms as a `bigint` column — exact, so `updateSchedule`'s compare-and-set can't be defeated
+     *  by a DATETIME's truncated milliseconds. Drivers may hand it back as a string. */
+    nextFireAt?: number | string | bigint | null;
+    tags?: string[] | null;
+    spec: Record<string, unknown>;
+    state: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
 declare function durableEntities(options?: {
     naming?: DurableColumnNaming;
 }): EntitySchema[];
@@ -167,13 +185,15 @@ declare class MikroOrmStateStore implements StateStore {
      */
     private fork;
     ensureSchema(): Promise<void>;
+    tryAdmitSingleton(runId: string, tag: string, workflow: string, limit: number, retryWakeAt?: number): Promise<boolean>;
     createRun(run: WorkflowRun): Promise<void>;
-    updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
+    updateRun(runId: string, inputPatch: Partial<WorkflowRun>): Promise<void>;
     /** Rewrite a run's normalized attribute rows: delete the old set, insert the current one. Mirrors
      *  the in-memory store's reindex so the side-table always reflects the run's live searchAttributes. */
     private reindexAttributes;
     getRun(runId: string): Promise<WorkflowRun | null>;
     deleteRun(runId: string): Promise<void>;
+    deleteRuns(runIds: string[]): Promise<void>;
     pruneTerminalRuns(policy: RetentionPolicy, nowMs: number, limit: number): Promise<number>;
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
@@ -199,6 +219,7 @@ declare class MikroOrmStateStore implements StateStore {
     /** `tags LIKE '%"etl"%'` — the quoted token, so `etl` doesn't match `etl-foo`. See the note in
      *  {@link listRuns} for why this is raw SQL rather than a MikroORM condition. */
     private tagLikeSql;
+    countRuns(query: Omit<RunQuery, 'limit' | 'offset'>): Promise<number>;
     /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
      *  console can show whole-set counts next to a bounded page instead of downloading every run to
      *  count them in the browser. */
@@ -257,6 +278,13 @@ declare class MikroOrmStateStore implements StateStore {
     private jsonAsText;
     /** Quote an identifier per the active SQL driver (MySQL/MariaDB backtick, others double-quote). */
     private idQuote;
+    saveSchedule(record: ScheduleRecord): Promise<void>;
+    getSchedule(id: string): Promise<ScheduleRecord | null>;
+    /** One conditional `nativeUpdate`: the compare-and-set on `next_fire_at` (an exact bigint) is a
+     *  single statement. */
+    updateSchedule(id: string, patch: Partial<Omit<ScheduleRecord, 'id' | 'createdAt'>>, expectedNextFireAt?: number | null): Promise<boolean>;
+    deleteSchedule(id: string): Promise<boolean>;
+    listSchedules(query: ScheduleQuery): Promise<ScheduleRecord[]>;
     listCheckpoints(runId: string): Promise<StepCheckpoint[]>;
     getLatestCheckpointByName(runId: string, name: string): Promise<StepCheckpoint | undefined>;
     listCheckpointsByNamePrefix(runId: string, prefixes: string[]): Promise<StepCheckpoint[]>;
@@ -327,4 +355,4 @@ declare function durableManagedTables(): string[];
  */
 declare function ensureMikroOrmDurableSchema(orm: MikroORM): Promise<void>;
 
-export { BufferedEventEntity, BufferedEventRepository, BufferedSignalEntity, BufferedSignalRepository, type DurableColumnNaming, ENTITIES, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, RunAttributeRepository, SignalWaiterEntity, SignalWaiterRepository, StepCheckpointEntity, StepCheckpointRepository, WorkflowRunEntity, WorkflowRunRepository, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema };
+export { BufferedEventEntity, BufferedEventRepository, BufferedSignalEntity, BufferedSignalRepository, type DurableColumnNaming, ENTITIES, MikroOrmStateStore, type MikroOrmStateStoreOptions, RunAttributeEntity, RunAttributeRepository, ScheduleEntity, ScheduleRepository, SignalWaiterEntity, SignalWaiterRepository, StepCheckpointEntity, StepCheckpointRepository, WorkflowRunEntity, WorkflowRunRepository, durableEntities, durableManagedTables, ensureMikroOrmDurableSchema };

package/dist/index.js

@@ -36,6 +36,11 @@ var BufferedEventRepository = class extends EntityRepository {
     __name(this, "BufferedEventRepository");
   }
 };
+var ScheduleRepository = class extends EntityRepository {
+  static {
+    __name(this, "ScheduleRepository");
+  }
+};
 
 // src/entities.ts
 function snakeCase(property) {
@@ -135,6 +140,24 @@ var BufferedEventEntity = class {
   payload;
   publishedAt;
 };
+var ScheduleEntity = class {
+  static {
+    __name(this, "ScheduleEntity");
+  }
+  [EntityRepositoryType];
+  id;
+  namespace;
+  workflow;
+  paused;
+  /** Epoch ms as a `bigint` column — exact, so `updateSchedule`'s compare-and-set can't be defeated
+  *  by a DATETIME's truncated milliseconds. Drivers may hand it back as a string. */
+  nextFireAt;
+  tags;
+  spec;
+  state;
+  createdAt;
+  updatedAt;
+};
 function namespaceFilterCond(args) {
   if (args?.namespace === void 0) return {};
   return {
@@ -534,20 +557,83 @@ function durableEntities(options = {}) {
       }
     }
   });
+  const schedules = new EntitySchema({
+    class: ScheduleEntity,
+    tableName: "durable_schedules",
+    repository: /* @__PURE__ */ __name(() => ScheduleRepository, "repository"),
+    // The poll's "due by T" scan: `paused = false AND next_fire_at <= T ORDER BY next_fire_at`.
+    indexes: [
+      {
+        name: "durable_schedules_due_idx",
+        properties: [
+          "paused",
+          "nextFireAt"
+        ]
+      }
+    ],
+    properties: {
+      id: {
+        type: "string",
+        primary: true,
+        fieldName: col("id")
+      },
+      namespace: {
+        type: "string",
+        default: "default",
+        fieldName: col("namespace")
+      },
+      workflow: {
+        type: "string",
+        fieldName: col("workflow")
+      },
+      paused: {
+        type: "boolean",
+        default: false,
+        fieldName: col("paused")
+      },
+      nextFireAt: {
+        type: "bigint",
+        nullable: true,
+        fieldName: col("nextFireAt")
+      },
+      tags: {
+        type: "json",
+        nullable: true,
+        fieldName: col("tags")
+      },
+      spec: {
+        type: "json",
+        fieldName: col("spec")
+      },
+      state: {
+        type: "json",
+        fieldName: col("state")
+      },
+      createdAt: {
+        type: "Date",
+        fieldName: col("createdAt")
+      },
+      updatedAt: {
+        type: "Date",
+        fieldName: col("updatedAt")
+      }
+    }
+  });
   return [
     workflowRuns,
     stepCheckpoints,
     runAttributes,
     signalWaiters,
     bufferedSignals,
-    bufferedEvents
+    bufferedEvents,
+    schedules
   ];
 }
 __name(durableEntities, "durableEntities");
 var ENTITIES = durableEntities();
 
 // src/mikro-orm-state-store.ts
-import { ENGINE_MINTED_TAG_PREFIXES, RUN_VALUE_FACET_LIMIT, attributePredicateOperands, axisIsRunColumn, facetOrigin, mergeRunFacetRows, normalizeAttributeRows, parseDuration } from "@dudousxd/nestjs-durable-core";
+import { ENGINE_MINTED_TAG_PREFIXES, RUN_VALUE_FACET_LIMIT, SINGLETON_ACTIVE_STATUSES, TERMINAL_RUN_STATUSES, attributePredicateOperands, axisIsRunColumn, clearTerminalSingletonAdmission, facetOrigin, mergeRunFacetRows, normalizeAttributeRows, parseDuration, singletonAdmissionDenialPatch, singletonAdmissionTags } from "@dudousxd/nestjs-durable-core";
 import { raw } from "@mikro-orm/core";
 
 // src/schema.ts
@@ -558,7 +644,8 @@ var DURABLE_TABLE_NAMES = /* @__PURE__ */ new Set([
   "durable_run_attributes",
   "durable_signal_waiters",
   "durable_buffered_signals",
-  "durable_buffered_events"
+  "durable_buffered_events",
+  "durable_schedules"
 ]);
 function durableManagedTables() {
   return [
@@ -805,13 +892,50 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
   async ensureSchema() {
     await ensureMikroOrmDurableSchema(this.orm);
   }
+  async tryAdmitSingleton(runId, tag, workflow, limit, retryWakeAt) {
+    return this.fork().transactional(async (em) => {
+      const where = {
+        workflow,
+        status: {
+          $in: SINGLETON_ACTIVE_STATUSES
+        },
+        ...this.scopeNamespace !== void 0 ? {
+          namespace: this.scopeNamespace
+        } : {}
+      };
+      await em.nativeUpdate(WorkflowRunEntity, where, {
+        workflow
+      });
+      const rows = await em.find(WorkflowRunEntity, where);
+      const runs = rows.map(fromRunEntity);
+      const tags = singletonAdmissionTags(runs, runId, tag, workflow, limit);
+      if (!tags) {
+        const patch = singletonAdmissionDenialPatch(runs, runId, tag, workflow, retryWakeAt);
+        if (patch) await em.nativeUpdate(WorkflowRunEntity, {
+          id: runId
+        }, {
+          status: "suspended",
+          wakeAt: new Date(patch.wakeAt),
+          updatedAt: patch.updatedAt
+        });
+        return false;
+      }
+      await em.nativeUpdate(WorkflowRunEntity, {
+        id: runId
+      }, {
+        tags
+      });
+      return true;
+    });
+  }
   async createRun(run) {
     const em = this.fork();
     em.create(WorkflowRunEntity, toRunEntity(run));
     await em.flush();
     await this.reindexAttributes(run.id, run.searchAttributes);
   }
-  async updateRun(runId, patch) {
+  async updateRun(runId, inputPatch) {
+    const patch = inputPatch.status && TERMINAL_RUN_STATUSES.includes(inputPatch.status) ? await clearTerminalSingletonAdmission(runId, inputPatch, (id) => this.withScope({}).getRun(id)) : inputPatch;
     const em = this.fork();
     const entity = await em.findOneOrFail(WorkflowRunEntity, {
       id: runId
@@ -855,71 +979,69 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
       id: runId
     });
   }
+  async deleteRuns(runIds) {
+    if (runIds.length === 0) return;
+    const runId = {
+      $in: runIds
+    };
+    await this.fork().transactional(async (tem) => {
+      await tem.nativeDelete(StepCheckpointEntity, {
+        runId
+      });
+      await tem.nativeDelete(SignalWaiterEntity, {
+        runId
+      });
+      await tem.nativeDelete(RunAttributeEntity, {
+        runId
+      });
+      await tem.nativeDelete(WorkflowRunEntity, {
+        id: runId
+      });
+    });
+  }
   async pruneTerminalRuns(policy, nowMs, limit) {
-    if (policy.statuses.length === 0 || limit <= 0) return 0;
+    const statuses = policy.statuses.filter((s) => TERMINAL_RUN_STATUSES.includes(s));
+    if (statuses.length === 0 || limit <= 0) return 0;
+    if (policy.maxAge == null && policy.maxCount == null) return 0;
     const em = this.fork();
-    const status = {
-      $in: policy.statuses
+    const meta = em.getMetadata().get(WorkflowRunEntity);
+    const idCol = meta.properties.id?.fieldNames?.[0] ?? "id";
+    const query = {
+      ...policy.scope ?? {},
+      statuses
     };
+    const scoped = /* @__PURE__ */ __name((extra) => this.runQueryBuilder(em, query, {
+      ...this.runWhere(query),
+      ...extra ?? {}
+    }).select([
+      `r.${idCol}`
+    ]), "scoped");
     const ids = /* @__PURE__ */ new Set();
     if (policy.maxAge != null) {
       const cutoff = new Date(nowMs - parseDuration(policy.maxAge));
-      const rows = await em.find(WorkflowRunEntity, {
-        status,
+      const rows = await scoped({
         updatedAt: {
           $lt: cutoff
         }
-      }, {
-        fields: [
-          "id"
-        ],
-        orderBy: {
-          updatedAt: "asc"
-        },
-        limit
-      });
-      for (const r of rows) ids.add(r.id);
+      }).orderBy({
+        "r.updatedAt": "asc"
+      }).limit(limit).execute();
+      for (const r of rows) ids.add(String(r[idCol] ?? r.id));
     }
     if (policy.maxCount != null && ids.size < limit) {
-      const rows = await em.find(WorkflowRunEntity, {
-        status
-      }, {
-        fields: [
-          "id"
-        ],
-        orderBy: {
-          updatedAt: "desc",
-          id: "desc"
-        },
-        limit,
-        offset: policy.maxCount
-      });
+      const rows = await scoped().orderBy({
+        "r.updatedAt": "desc",
+        "r.id": "desc"
+      }).limit(limit).offset(policy.maxCount).execute();
       for (const r of rows) {
-        ids.add(r.id);
         if (ids.size >= limit) break;
+        ids.add(String(r[idCol] ?? r.id));
       }
     }
-    if (ids.size === 0) return 0;
     const idList = [
       ...ids
     ].slice(0, limit);
-    const runId = {
-      $in: idList
-    };
-    await em.transactional(async (tem) => {
-      await tem.nativeDelete(StepCheckpointEntity, {
-        runId
-      });
-      await tem.nativeDelete(SignalWaiterEntity, {
-        runId
-      });
-      await tem.nativeDelete(RunAttributeEntity, {
-        runId
-      });
-      await tem.nativeDelete(WorkflowRunEntity, {
-        id: runId
-      });
-    });
+    await this.deleteRuns(idList);
     return idList.length;
   }
   async getCheckpoint(runId, seq) {
@@ -1131,6 +1253,11 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     const colExpr = this.jsonAsText(em, `${quote("r")}.${quote(this.tagsColumn(em))}`);
     return `${colExpr} LIKE '${pattern}'`;
   }
+  async countRuns(query) {
+    const em = this.fork();
+    const rows = await this.runQueryBuilder(em, query, this.runWhere(query)).select([]).addSelect(raw("count(*) as count")).execute();
+    return Number(rows[0]?.count ?? 0);
+  }
   /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
   *  console can show whole-set counts next to a bounded page instead of downloading every run to
   *  count them in the browser. */
@@ -1322,6 +1449,76 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     const ch = isMysql ? "`" : '"';
     return (id) => `${ch}${id}${ch}`;
   }
+  // ---- persisted schedules ----------------------------------------------------------------------
+  async saveSchedule(record) {
+    const em = this.fork();
+    await em.upsert(ScheduleEntity, toScheduleEntity(record));
+  }
+  async getSchedule(id) {
+    const entity = await this.fork().findOne(ScheduleEntity, {
+      id
+    });
+    return entity ? fromScheduleEntity(entity) : null;
+  }
+  /** One conditional `nativeUpdate`: the compare-and-set on `next_fire_at` (an exact bigint) is a
+  *  single statement. */
+  async updateSchedule(id, patch, expectedNextFireAt) {
+    const data = {};
+    if (patch.namespace !== void 0) data.namespace = patch.namespace;
+    if (patch.workflow !== void 0) data.workflow = patch.workflow;
+    if (patch.paused !== void 0) data.paused = patch.paused;
+    if ("nextFireAt" in patch) data.nextFireAt = patch.nextFireAt ?? null;
+    if ("tags" in patch) data.tags = patch.tags ?? null;
+    if (patch.spec !== void 0) data.spec = patch.spec;
+    if (patch.state !== void 0) data.state = patch.state;
+    if (patch.updatedAt !== void 0) data.updatedAt = patch.updatedAt;
+    if (!Object.keys(data).length) return await this.getSchedule(id) !== null;
+    const where = {
+      id
+    };
+    if (expectedNextFireAt !== void 0) where.nextFireAt = expectedNextFireAt;
+    const affected = await this.fork().nativeUpdate(ScheduleEntity, where, data);
+    return affected > 0;
+  }
+  async deleteSchedule(id) {
+    return await this.fork().nativeDelete(ScheduleEntity, {
+      id
+    }) > 0;
+  }
+  async listSchedules(query) {
+    const em = this.fork();
+    const where = {};
+    if (query.namespace !== void 0) where.namespace = query.namespace;
+    if (query.workflow !== void 0) where.workflow = query.workflow;
+    if (query.paused !== void 0) where.paused = query.paused;
+    if (query.dueBy !== void 0) {
+      where.$and = [
+        {
+          paused: false
+        },
+        {
+          nextFireAt: {
+            $lte: query.dueBy
+          }
+        }
+      ];
+    }
+    const quote = this.idQuote(em);
+    const meta = em.getMetadata().get(ScheduleEntity);
+    const tagsCol = meta.properties.tags?.fieldNames?.[0] ?? "tags";
+    const qb = em.createQueryBuilder(ScheduleEntity, "r").where(where);
+    if (query.tag !== void 0) {
+      const pattern = `%"${query.tag.replace(/'/g, "''")}"%`;
+      qb.andWhere(`${this.jsonAsText(em, `${quote("r")}.${quote(tagsCol)}`)} LIKE '${pattern}'`);
+    }
+    qb.orderBy({
+      "r.nextFireAt": "asc nulls last",
+      "r.id": "asc"
+    });
+    if (query.limit != null) qb.limit(query.limit);
+    if (query.offset != null) qb.offset(query.offset);
+    return (await qb.getResultList()).map(fromScheduleEntity);
+  }
   async listCheckpoints(runId) {
     const em = this.fork();
     const rows = await em.find(StepCheckpointEntity, {
@@ -1560,6 +1757,38 @@ function fromCheckpointEntity(e) {
   };
 }
 __name(fromCheckpointEntity, "fromCheckpointEntity");
+function toScheduleEntity(r) {
+  const e = new ScheduleEntity();
+  e.id = r.id;
+  e.namespace = r.namespace;
+  e.workflow = r.workflow;
+  e.paused = r.paused;
+  e.nextFireAt = r.nextFireAt;
+  e.tags = r.tags ?? null;
+  e.spec = r.spec;
+  e.state = r.state;
+  e.createdAt = r.createdAt;
+  e.updatedAt = r.updatedAt;
+  return e;
+}
+__name(toScheduleEntity, "toScheduleEntity");
+function fromScheduleEntity(e) {
+  return {
+    id: e.id,
+    namespace: e.namespace,
+    workflow: e.workflow,
+    paused: Boolean(e.paused),
+    nextFireAt: e.nextFireAt == null ? null : Number(e.nextFireAt),
+    ...e.tags?.length ? {
+      tags: e.tags
+    } : {},
+    spec: e.spec ?? {},
+    state: e.state ?? {},
+    createdAt: e.createdAt,
+    updatedAt: e.updatedAt
+  };
+}
+__name(fromScheduleEntity, "fromScheduleEntity");
 export {
   BufferedEventEntity,
   BufferedEventRepository,
@@ -1569,6 +1798,8 @@ export {
   MikroOrmStateStore,
   RunAttributeEntity,
   RunAttributeRepository,
+  ScheduleEntity,
+  ScheduleRepository,
   SignalWaiterEntity,
   SignalWaiterRepository,
   StepCheckpointEntity,