@warlock.js/cascade 4.0.171 → 4.1.1

package/skills/subscribe-to-model-events/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: subscribe-to-model-events
+description: 'Hook into model lifecycle events — `saving` / `saved`, `creating` / `created`, `updating` / `updated`, `validating` / `validated`, `deleting` / `deleted`, `restoring` / `restored`, `fetching` / `fetched`. Per-model `Model.on(event, fn)` or global via `Model.globalEvents()`. Triggers: `Model.on`, `Model.off`, `saving`, `saved`, `created`, `updated`, `deleting`, `deleted`, `restored`; "audit log on save", "notify on change", "denormalize into search index"; typical import `import { Model } from "@warlock.js/cascade"`. Skip: dirty tracking — `@warlock.js/cascade/track-changes/SKILL.md`; competing libs `mongoose` middleware, `typeorm` subscribers, `prisma` extensions.'
+---
+
+# Use model events
+
+Every meaningful moment in a model's lifecycle — about to validate, about to save, just saved, just deleted — fires an event. Subscribe to hook in cross-cutting behavior without scattering it across every service.
+
+## Subscribing — per-model
+
+```ts
+User.on("saved", async (user) => {
+  await searchIndex.upsert({ id: user.id, name: user.get("name") });
+});
+
+User.on("deleted", async (user) => {
+  await searchIndex.remove(user.id);
+});
+```
+
+Listeners are async-aware — the model's persistence awaits the listener before moving on. A listener that throws during a pre-write event (`saving` / `creating` / `updating` / `validating`) aborts the operation; the error propagates to the caller.
+
+## The full event catalog
+
+The events fire in this order. The **gerund** form (`saving`, `creating`) is the "before" hook — there is no `beforeSave` alias.
+
+| Event | Fires |
+| --- | --- |
+| `saving` | Before validation, on every `save()` (both insert and update paths) |
+| `validating` / `validated` | Around schema validation |
+| `creating` | Before a new record is inserted (first save) |
+| `updating` | Before an existing record's update is written |
+| `saved` | After a successful write (any branch — insert or update) |
+| `created` | After a new record is inserted |
+| `updated` | After an existing record's update is written |
+| `deleting` / `deleted` | Before / after the delete strategy runs |
+| `restoring` / `restored` | Before / after a soft-deleted or trashed record is restored |
+| `fetching` / `fetched` / `hydrating` | Around reads / instance hydration |
+
+`saving` fires for both inserts and updates; `creating` / `updating` narrow to the branch. So `saved` always fires; exactly one of `created` / `updated` follows.
+
+## Listener signature
+
+```ts
+User.on("saving", async (user, context) => {
+  // user:    the User instance about to be persisted
+  // context: { isInsert, options, mode } for `saving`; varies per event
+});
+```
+
+The first argument is the model instance. The second carries event context (for `saving`: whether it's an insert, the `save()` options, and the mode).
+
+## Throwing to abort
+
+A listener on a pre-write event that throws stops the lifecycle — the save / delete never completes and the error propagates:
+
+```ts
+User.on("saving", async (user) => {
+  if (user.isDirty("email") && (await emailIsBlacklisted(user.get("email")))) {
+    throw new Error("Email domain is blacklisted");
+  }
+});
+```
+
+Pair with `isDirty()` from [`@warlock.js/cascade/track-changes/SKILL.md`](@warlock.js/cascade/track-changes/SKILL.md) so the listener only runs its expensive check when the relevant field changed.
+
+## Global listeners — across all models
+
+For framework-level concerns (audit log, observability, cache invalidation), subscribe on the base `Model` — the listener runs for every model:
+
+```ts
+import { Model } from "@warlock.js/cascade";
+
+Model.on("saved", async (instance) => {
+  await audit.log("save", instance.constructor.name, instance.id, instance.getDirtyColumns());
+});
+```
+
+Filter by `instance.constructor.name === "User"` when you only care about specific models, or register per-model handlers when the scope is narrow. (`Model.globalEvents()` returns the underlying global emitter if you need direct access.)
+
+## `off()` to unsubscribe
+
+```ts
+const handler = async (user) => {
+  /* ... */
+};
+const unsubscribe = User.on("saved", handler);
+
+// later — either:
+unsubscribe();
+// or:
+User.off("saved", handler);
+```
+
+`on()` also returns an unsubscribe function. Mostly useful in tests where you want to temporarily swap behavior.
+
+## Common patterns
+
+### Audit log (combined with dirty tracking)
+
+```ts
+Model.on("updated", async (instance) => {
+  const changes = instance.getDirtyColumnsWithValues();
+  if (Object.keys(changes).length === 0) {
+    return;
+  }
+
+  await AuditLog.create({
+    model: instance.constructor.name,
+    record_id: instance.id,
+    changes,
+    saved_at: new Date(),
+  });
+});
+```
+
+Use `updated` (not `saved`) when you only want change diffs — `getDirtyColumnsWithValues()` is still populated in the post-write events because the tracker resets *after* they fire.
+
+### Cache invalidation
+
+```ts
+User.on("saved", async (user) => {
+  await cache.tags([`user.${user.id}`]).invalidate();
+});
+
+User.on("deleted", async (user) => {
+  await cache.tags([`user.${user.id}`]).invalidate();
+});
+```
+
+See [`@warlock.js/cache/use-cache-tags/SKILL.md`](@warlock.js/cache/use-cache-tags/SKILL.md).
+
+### Side effects that must only fire after commit
+
+For external side effects (queues, emails) that must only fire if a surrounding transaction commits, don't run them in the `saved` handler — write to an outbox table and dispatch from a worker after commit.
+
+## Things NOT to do
+
+- Don't reach for `beforeSave` / `destroying` / `destroyed` — they don't exist. The hooks are `saving` (pre-save) and `deleting` / `deleted`.
+- Don't run long external work (HTTP calls, queue dispatches) directly in `saving` / `saved` handlers — inside a transaction they extend the lock. Use an outbox table.
+- Don't mutate the model's own fields in `saved` and expect them to persist. The write already happened; mutations here are in-memory only. Use `saving` for pre-persist mutation.
+- Don't subscribe inside a function that runs on every request. Register handlers once at startup, in a dedicated init file.
+
+## See also
+
+- [`@warlock.js/cascade/track-changes/SKILL.md`](@warlock.js/cascade/track-changes/SKILL.md) — `isDirty` / `getDirtyColumnsWithValues` for "only run if this field changed"
+- [`@warlock.js/cascade/configure-delete-strategy/SKILL.md`](@warlock.js/cascade/configure-delete-strategy/SKILL.md) — `deleting` / `deleted` / `restored` around delete strategies

package/skills/track-changes/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: track-changes
+description: 'Inspect a model''s pending changes — `hasChanges()` (any field dirty?), `isDirty(column)` (one column), `getDirtyColumns()` (changed field names), `getDirtyColumnsWithValues()` (old + new per field), `getRemovedColumns()` (unset fields). Triggers: `hasChanges`, `isDirty`, `getDirtyColumns`, `getDirtyColumnsWithValues`, `getRemovedColumns`; "only run if email changed", "diff for an audit log", "what fields are dirty", "compare old vs new value"; typical import `import { Model } from "@warlock.js/cascade"`. Skip: hooking into save — `@warlock.js/cascade/subscribe-to-model-events/SKILL.md`; update idioms — `@warlock.js/cascade/define-model/SKILL.md`; competing libs `mongoose` `isModified` / `modifiedPaths`, `typeorm` change detection.'
+---
+
+# Track changes
+
+Every Cascade model carries a dirty tracker that records which fields you've changed since the model was loaded (or since the last `save()`). The tracker is the source of truth for "what would change if I save now."
+
+## The main reads
+
+```ts
+user.hasChanges();           // boolean — any field changed (or removed)?
+user.isDirty("email");       // boolean — specifically this column?
+
+user.getDirtyColumns();      // string[] — names of changed columns
+user.getRemovedColumns();    // string[] — columns explicitly unset since load
+
+user.getDirtyColumnsWithValues();
+// Record<string, { oldValue, newValue }> — the full diff, old + new per column
+```
+
+`isDirty` takes **one** column. To check several, ask `getDirtyColumns()` once and test membership (see the multi-field section below).
+
+## Conditional logic before save
+
+```ts
+if (user.isDirty("email")) {
+  const { oldValue } = user.getDirtyColumnsWithValues().email;
+  await mailer.sendEmailChangeNotice(oldValue);
+}
+
+await user.save();
+```
+
+The classic shape — only fire the side effect if the field actually changed. The pre-mutation value comes from `getDirtyColumnsWithValues()[column].oldValue`.
+
+## Diff for an audit log
+
+```ts
+const changes = user.getDirtyColumnsWithValues();
+// e.g. { name: { oldValue: "Ada", newValue: "Augusta Ada King" } }
+
+await AuditLog.create({
+  user_id: user.id,
+  before: Object.fromEntries(
+    Object.entries(changes).map(([field, { oldValue }]) => [field, oldValue]),
+  ),
+  after: Object.fromEntries(
+    Object.entries(changes).map(([field, { newValue }]) => [field, newValue]),
+  ),
+  changed_at: new Date(),
+});
+```
+
+`getDirtyColumnsWithValues()` hands you old and new together, so you never need a second call to read the prior value.
+
+## After save — tracker resets
+
+```ts
+user.set("name", "Augusta");
+user.isDirty("name");        // true
+await user.save();
+user.isDirty("name");        // false — tracker reset to the just-saved state
+```
+
+`save()` resets the tracker's baseline to the persisted state. Subsequent `isDirty()` checks measure changes since the last `save()`, not since the original load.
+
+## Multi-field check
+
+`isDirty` is single-column. For "did any of these change?", read the dirty set once:
+
+```ts
+const dirty = new Set(user.getDirtyColumns());
+const billingTouched = ["billing_address", "billing_city", "billing_zip"].some((field) =>
+  dirty.has(field),
+);
+
+if (billingTouched) {
+  await revalidateBillingAddress(user);
+}
+```
+
+## Tracker vs `.get()`
+
+- `user.get("email")` — the **current** value (post-mutation if you called `.set` / `.merge`)
+- `user.getDirtyColumnsWithValues().email?.oldValue` — the **pre-mutation** value (whatever the DB had)
+- `user.getDirtyColumns()` — the **changed field names** (string array)
+- `user.getDirtyColumnsWithValues()` — the **full diff** (old + new per changed field)
+
+If you need both old and new together:
+
+```ts
+const dirty = user.getDirtyColumnsWithValues();
+for (const [field, { oldValue, newValue }] of Object.entries(dirty)) {
+  // ... log, validate, conditionally re-route
+}
+```
+
+## Things NOT to do
+
+- Don't use `hasChanges()` / `isDirty()` after `save()` to verify the save persisted. The tracker resets to clean on save — these become false regardless. Read back from the DB if you need verification.
+- Don't compare `user.get(field) === oldValue` for change detection — call `isDirty(field)` instead. The tracker uses identity-aware comparison appropriate to the column type (deep-equal for objects/arrays).
+- Don't expect dirty tracking on relations. The tracker covers columns only. For relation changes, use lifecycle events or compare counts.
+
+## See also
+
+- [`@warlock.js/cascade/subscribe-to-model-events/SKILL.md`](@warlock.js/cascade/subscribe-to-model-events/SKILL.md) — combining with `saved` / `saving` for cross-cutting behavior
+- [`@warlock.js/cascade/define-model/SKILL.md`](@warlock.js/cascade/define-model/SKILL.md) — the `.set` / `.merge` / `.save` idioms that stage changes

package/skills/write-migration/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: write-migration
+description: 'Write a Cascade migration — the declarative `Migration.create(Model, { columns })` / `Migration.alter(Model, { ... })` factory is the primary form (column helpers `string` / `text` / `uuid` / `integer` imported from cascade, chained with `.notNullable()` / `.unique()` / `.references()`); the `extends Migration` class form is the imperative escape hatch. Run with the `cascade migrate` CLI; pin a source via `public dataSource`. Triggers: `Migration.create`, `Migration.alter`, `string()`, `text()`, `uuid()`, `.references`, `extends Migration`, `cascade migrate`; "write a migration", "create the users table", "add a column", "rollback the last batch"; typical import `import { Migration, text, uuid } from "@warlock.js/cascade"`. Skip: running migrations programmatically — `@warlock.js/cascade/run-cascade-cli/SKILL.md`; per-source migrations — `@warlock.js/cascade/manage-data-sources/SKILL.md`; competing tools `knex migrate`, `prisma migrate`, `typeorm migration`.'
+---
+
+# Write a migration
+
+The model class doesn't auto-create tables. Migrations declare the schema change in a versioned file; the CLI applies them in order for a reproducible DB shape across environments.
+
+The primary form is **declarative**: `Migration.create(Model, { columns })` reads the table name from the model and builds the columns from the object you pass. Reach for the imperative `extends Migration` class form only when a migration is genuinely procedural.
+
+## Minimal example — `Migration.create`
+
+```ts title="src/app/users/models/user/migrations/05-11-2026_10-00-00-user.migration.ts"
+import { Migration, text, uuid } from "@warlock.js/cascade";
+import { User } from "../user.model";
+
+export default Migration.create(User, {
+  name: text().notNullable(),
+  email: text().unique().notNullable(),
+  status: text().notNullable(),
+});
+```
+
+What happens:
+
+- `Migration.create(Model, columns)` reads `User.table` for the table name and builds the DDL from the column map; it infers the rollback for you.
+- Column helpers (`text`, `uuid`, `string`, `integer`, …) are imported from `@warlock.js/cascade`. Each returns a builder you chain modifiers onto (`.notNullable()`, `.unique()`, `.nullable()`, `.default(...)`, `.references(table)`).
+- The `id` primary key and `createdAt` / `updatedAt` timestamps are added **automatically** — don't declare them. Naming follows the data source convention (snake_case on Postgres, camelCase on MongoDB).
+- `export default` is required — the runner imports each file's default export.
+
+Evolve an existing table with `Migration.alter(Model, { ... })` (add / drop / rename / modify columns and indexes); it's declarative the same way.
+
+## Running migrations
+
+```bash
+yarn cascade migrate            # apply pending migrations
+yarn cascade migrate:rollback   # undo the last batch
+yarn cascade migrate:list       # which migrations have been executed
+yarn cascade migrate:export-sql # write .up.sql / .down.sql instead of executing
+```
+
+`cascade migrate` discovers migration files via the `-p`/`--path` glob (default `./migrations/**`), runs them in order, and records each in the `_migrations` table / collection. See [`@warlock.js/cascade/run-cascade-cli/SKILL.md`](@warlock.js/cascade/run-cascade-cli/SKILL.md) for every flag and the programmatic Operations API.
+
+## File naming convention
+
+Name files with a timestamp prefix (`MM-DD-YYYY_HH-MM-SS-<name>.migration.ts`) so Cascade orders runs deterministically and infers the migration name from the filename. A timestamp prefix prevents the "two devs picked the same number" merge conflict.
+
+## Column helpers — the building blocks
+
+Every column in a `Migration.create` / `Migration.alter` map starts with a helper imported from `@warlock.js/cascade`; each returns a builder you chain modifiers onto (`.notNullable()`, `.nullable()`, `.unique()`, `.default(value)`, `.index()`, `.primary()`, `.references(table)`):
+
+```ts
+import { Migration, text, integer, json, timestamp, uuid } from "@warlock.js/cascade";
+import { User } from "../user.model";
+
+export default Migration.create(Post, {
+  title: text().notNullable(),
+  body: text().nullable(),
+  author_id: uuid().references(User.table).onDelete("cascade").notNullable(),
+  status: text().notNullable(),
+  metadata: json(), // JSON / JSONB column
+  published_at: timestamp().nullable(),
+});
+```
+
+`references(table)` defaults to the referenced table's `id` column; chain `.on("custom_id")` for a different one, and `.onDelete(...)` / `.onUpdate(...)` for FK actions. `id`, `createdAt`, and `updatedAt` are still added for you. The full helper vocabulary (`string`, `char`, `integer`, `bigInteger`, `decimal`, `boolCol`, `date`, `dateTime`, `uuid`, `ulid`, `enumCol`, `vector`, the `array*` family, …) lives in the migrations guide.
+
+## Imperative escape hatch — `extends Migration`
+
+When a migration is genuinely procedural (a runtime `hasIndex` check, branching on existing schema, interleaving DDL and data), drop to the class form. Here the column types are methods on `this`:
+
+```ts
+import { Migration } from "@warlock.js/cascade";
+
+export default class BackfillStatuses extends Migration {
+  public readonly table = "posts";
+
+  public async up(): Promise<void> {
+    if (!(await this.hasColumn("status"))) {
+      this.string("status").defaultString("draft");
+    }
+
+    this.raw(`UPDATE posts SET status = 'published' WHERE published_at IS NOT NULL`);
+  }
+
+  public down(): void {
+    this.dropColumn("status");
+  }
+}
+```
+
+Class-form builders include `createTable()` / `createTableIfNotExists()`, `dropTable()` / `dropTableIfExists()`, `dropColumn(name)`, `renameTableTo(name)`, `timestamps()`, `index(...)`, `primaryUuid()`, and `raw(sql)` for a raw statement.
+
+## Raw SQL migrations
+
+For SQL-only changes (Postgres), `Migration.rawSql` builds a migration class for you:
+
+```ts
+export default Migration.rawSql({
+  name: "2026-01-01-create-auth",
+  up: [`CREATE TABLE sessions (id UUID PRIMARY KEY, user_id UUID REFERENCES users(id))`],
+  down: [`DROP TABLE sessions`],
+});
+```
+
+(Throws on MongoDB — use the declarative or class form there.)
+
+## Reversibility
+
+For the class form, `down()` should undo `up()` — the CLI calls it on rollback. (`Migration.create` infers the rollback automatically.) If a migration is genuinely one-way, throw inside `down()` so accidental rollbacks fail loudly:
+
+```ts
+public down(): void {
+  throw new Error("This migration is irreversible — restore from backup if you need to undo it.");
+}
+```
+
+## Data-source-aware migrations
+
+A `Migration.create` / `Migration.alter` migration **inherits its data source from the model** — whatever `static dataSource = "analytics"` the model declares, the migration runs against. You don't pass it in the options.
+
+```ts
+// AnalyticsEvent has `static dataSource = "analytics"`, so this migration
+// targets the analytics database automatically.
+export default Migration.create(AnalyticsEvent, {
+  type: text().notNullable(),
+});
+```
+
+For a class-form migration not bound to a model, set `public readonly dataSource = "analytics"` directly. See [`@warlock.js/cascade/manage-data-sources/SKILL.md`](@warlock.js/cascade/manage-data-sources/SKILL.md) for the registry.
+
+## Things NOT to do
+
+- Don't reach for a `migration({ up(driver) {...} })` factory or `driver.createTable(name, (table) => {...})` — that API doesn't exist. Use `Migration.create(Model, { columns })`, or `extends Migration` with `this.createTable()` for the imperative case.
+- Don't declare `id` / `createdAt` / `updatedAt` — they're added for you.
+- Don't auto-run migrations from app code in production. Run them as a deploy step.
+- Don't put irreversible data backfills in the same file as a schema change — split them so rollback only undoes the schema.
+- Don't change a committed migration. Add a new one. Editing a migration that already ran in production puts environments out of sync.
+
+## See also
+
+- [`@warlock.js/cascade/run-cascade-cli/SKILL.md`](@warlock.js/cascade/run-cascade-cli/SKILL.md) — CLI flags + Operations API for programmatic runs
+- [`@warlock.js/cascade/manage-data-sources/SKILL.md`](@warlock.js/cascade/manage-data-sources/SKILL.md) — multi-DB migrations

package/cjs/context/database-data-source-context.d.ts

@@ -1,29 +0,0 @@
-import { Context } from "@warlock.js/context";
-import type { DataSource } from "../data-source/data-source";
-type DataSourceContextValue = string | DataSource;
-type DataSourceContextStore = {
-    dataSource?: DataSourceContextValue;
-};
-/**
- * Database DataSource Context
- *
- * Manages the active database connection/data source using AsyncLocalStorage.
- * Extends the base Context class for consistent API.
- */
-declare class DatabaseDataSourceContext extends Context<DataSourceContextStore> {
-    /**
-     * Get the current data source
-     */
-    getDataSource(): DataSourceContextValue | undefined;
-    /**
-     * Set the data source in context
-     */
-    setDataSource(dataSource: DataSourceContextValue): void;
-    /**
-     * Build the initial data source store with defaults
-     */
-    buildStore(): DataSourceContextStore;
-}
-export declare const databaseDataSourceContext: DatabaseDataSourceContext;
-export {};
-//# sourceMappingURL=database-data-source-context.d.ts.map

package/cjs/context/database-data-source-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"database-data-source-context.d.ts","sourceRoot":"","sources":["../../src/context/database-data-source-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAkB,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,KAAK,sBAAsB,GAAG,MAAM,GAAG,UAAU,CAAC;AAElD,KAAK,sBAAsB,GAAG;IAC5B,UAAU,CAAC,EAAE,sBAAsB,CAAC;CACrC,CAAC;AAEF;;;;;GAKG;AACH,cAAM,yBAA0B,SAAQ,OAAO,CAAC,sBAAsB,CAAC;IACrE;;OAEG;IACI,aAAa,IAAI,sBAAsB,GAAG,SAAS;IAI1D;;OAEG;IACI,aAAa,CAAC,UAAU,EAAE,sBAAsB,GAAG,IAAI;IAI9D;;OAEG;IACI,UAAU,IAAI,sBAAsB;CAG5C;AAED,eAAO,MAAM,yBAAyB,2BAAkC,CAAC"}

package/cjs/context/database-data-source-context.js

@@ -1,28 +0,0 @@
-'use strict';var context=require('@warlock.js/context');/**
- * Database DataSource Context
- *
- * Manages the active database connection/data source using AsyncLocalStorage.
- * Extends the base Context class for consistent API.
- */
-class DatabaseDataSourceContext extends context.Context {
-    /**
-     * Get the current data source
-     */
-    getDataSource() {
-        return this.get("dataSource");
-    }
-    /**
-     * Set the data source in context
-     */
-    setDataSource(dataSource) {
-        this.set("dataSource", dataSource);
-    }
-    /**
-     * Build the initial data source store with defaults
-     */
-    buildStore() {
-        return { dataSource: undefined };
-    }
-}
-const databaseDataSourceContext = new DatabaseDataSourceContext();
-context.contextManager.register("db.datasource", databaseDataSourceContext);exports.databaseDataSourceContext=databaseDataSourceContext;//# sourceMappingURL=database-data-source-context.js.map

package/cjs/context/database-data-source-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"database-data-source-context.js","sources":["../../src/context/database-data-source-context.ts"],"sourcesContent":[null],"names":["Context","contextManager"],"mappings":"wDASA;;;;;AAKG;AACH,MAAM,yBAA0B,SAAQA,eAA+B,CAAA;AACrE;;AAEG;IACI,aAAa,GAAA;AAClB,QAAA,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;KAC/B;AAED;;AAEG;AACI,IAAA,aAAa,CAAC,UAAkC,EAAA;AACrD,QAAA,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;KACpC;AAED;;AAEG;IACI,UAAU,GAAA;AACf,QAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;KAClC;AACF,CAAA;AAEY,MAAA,yBAAyB,GAAG,IAAI,yBAAyB,GAAG;AAEzEC,sBAAc,CAAC,QAAQ,CAAC,eAAe,EAAE,yBAAyB,CAAC"}

package/cjs/context/database-transaction-context.d.ts

@@ -1,35 +0,0 @@
-import { Context } from "@warlock.js/context";
-interface TransactionContextStore {
-    session?: unknown;
-}
-/**
- * Database Transaction Context
- *
- * Manages database transaction sessions using AsyncLocalStorage.
- * Extends the base Context class for consistent API.
- */
-declare class DatabaseTransactionContext extends Context<TransactionContextStore> {
-    /**
-     * Get the current transaction session
-     */
-    getSession<TSession = unknown>(): TSession | undefined;
-    /**
-     * Check if there's an active transaction in the current context
-     */
-    hasActiveTransaction(): boolean;
-    /**
-     * Set the transaction session in context
-     */
-    setSession(session: unknown): void;
-    /**
-     * Exit the transaction context
-     */
-    exit(): void;
-    /**
-     * Build the initial transaction store with defaults
-     */
-    buildStore(): TransactionContextStore;
-}
-export declare const databaseTransactionContext: DatabaseTransactionContext;
-export {};
-//# sourceMappingURL=database-transaction-context.d.ts.map

package/cjs/context/database-transaction-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"database-transaction-context.d.ts","sourceRoot":"","sources":["../../src/context/database-transaction-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAkB,MAAM,qBAAqB,CAAC;AAE9D,UAAU,uBAAuB;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;GAKG;AACH,cAAM,0BAA2B,SAAQ,OAAO,CAAC,uBAAuB,CAAC;IACvE;;OAEG;IACI,UAAU,CAAC,QAAQ,GAAG,OAAO,KAAK,QAAQ,GAAG,SAAS;IAI7D;;OAEG;IACI,oBAAoB,IAAI,OAAO;IAItC;;OAEG;IACI,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIzC;;OAEG;IACI,IAAI,IAAI,IAAI;IAInB;;OAEG;IACI,UAAU,IAAI,uBAAuB;CAG7C;AAED,eAAO,MAAM,0BAA0B,4BAAmC,CAAC"}

package/cjs/context/database-transaction-context.js

@@ -1,40 +0,0 @@
-'use strict';var context=require('@warlock.js/context');/**
- * Database Transaction Context
- *
- * Manages database transaction sessions using AsyncLocalStorage.
- * Extends the base Context class for consistent API.
- */
-class DatabaseTransactionContext extends context.Context {
-    /**
-     * Get the current transaction session
-     */
-    getSession() {
-        return this.get("session");
-    }
-    /**
-     * Check if there's an active transaction in the current context
-     */
-    hasActiveTransaction() {
-        return this.getSession() !== undefined;
-    }
-    /**
-     * Set the transaction session in context
-     */
-    setSession(session) {
-        this.set("session", session);
-    }
-    /**
-     * Exit the transaction context
-     */
-    exit() {
-        this.clear();
-    }
-    /**
-     * Build the initial transaction store with defaults
-     */
-    buildStore() {
-        return { session: undefined };
-    }
-}
-const databaseTransactionContext = new DatabaseTransactionContext();
-context.contextManager.register("db.transaction", databaseTransactionContext);exports.databaseTransactionContext=databaseTransactionContext;//# sourceMappingURL=database-transaction-context.js.map

package/cjs/context/database-transaction-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"database-transaction-context.js","sources":["../../src/context/database-transaction-context.ts"],"sourcesContent":[null],"names":["Context","contextManager"],"mappings":"wDAMA;;;;;AAKG;AACH,MAAM,0BAA2B,SAAQA,eAAgC,CAAA;AACvE;;AAEG;IACI,UAAU,GAAA;AACf,QAAA,OAAO,IAAI,CAAC,GAAG,CAAC,SAAS,CAAyB,CAAC;KACpD;AAED;;AAEG;IACI,oBAAoB,GAAA;AACzB,QAAA,OAAO,IAAI,CAAC,UAAU,EAAE,KAAK,SAAS,CAAC;KACxC;AAED;;AAEG;AACI,IAAA,UAAU,CAAC,OAAgB,EAAA;AAChC,QAAA,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;KAC9B;AAED;;AAEG;IACI,IAAI,GAAA;QACT,IAAI,CAAC,KAAK,EAAE,CAAC;KACd;AAED;;AAEG;IACI,UAAU,GAAA;AACf,QAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;KAC/B;AACF,CAAA;AAEY,MAAA,0BAA0B,GAAG,IAAI,0BAA0B,GAAG;AAE3EC,sBAAc,CAAC,QAAQ,CAAC,gBAAgB,EAAE,0BAA0B,CAAC"}