@spinajs/session-provider-db 2.0.488 → 2.0.490

package/lib/mjs/migrations/UserSessionDataJson_2026_07_31_00_00_00.js

@@ -0,0 +1,141 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+import { Migration, OrmMigration } from '@spinajs/orm';
+import { columnNativeType, isMySqlDialect, isTextFamily } from '../migration-support.js';
+/**
+ * Converts an EXISTING text-typed `user_sessions.Data` to a native MySQL `json`
+ * column, so the read path receives a parsed object graph instead of text.
+ *
+ * Databases created before the create-path migration
+ * (`UserSessionDBSqlMigration_2022_06_28_01_20_00`) declared `json` - i.e. every
+ * deployment - carry `Data text NOT NULL`. The create migration returns early
+ * when the table is already there, so the type it declares has never reached
+ * them. Fresh installs already get `json`. Two shapes of the same table exist in
+ * the wild and nothing detected which one you had; this migration ends that.
+ *
+ * mysql2 parses a json column on the way out, so the read path receives the
+ * payload as a live object graph and rebuilds the session `Map` from it directly
+ * (`decodeSessionData`). The write path is unchanged - `encodeSessionData` still
+ * produces JSON text, which a json column stores verbatim.
+ *
+ * Everything below is a guard. Read them in order.
+ *
+ * 1. Table missing: nothing to converge
+ * ---------------------------------------
+ * It normally IS there - the create migration carries an earlier timestamp and
+ * runs first in the same batch - but a connection that hosts only part of the
+ * schema must not blow up here.
+ *
+ * 2. Column state probe: skip unless it is text-family
+ * ------------------------------------------------------
+ * The previous version of this migration was unconditional, on the argument that
+ * `MODIFY` to a type a column already has is a harmless rewrite. True on MySQL,
+ * and irrelevant everywhere else: it reached the schema builder's `alterTable()`,
+ * which resolves `AlterTableQueryCompiler` - and `orm-mssql` registers no
+ * implementation for it, so DI hands back the ABSTRACT class, whose `compile()`
+ * does not exist. That throw is recorded as a FAILED migration, and
+ * `assertNoFailed()` then refuses to run ANY migration on that connection ever
+ * again: the application never boots without manual surgery on the tracking
+ * table. Probing the target state first and returning early is the same shape
+ * `@spinajs/rbac`'s `RBACRegisteredAt_2026_07_28_00_00_00` already uses, and it
+ * makes the no-op case genuinely free rather than merely survivable.
+ *
+ * An unreadable probe skips too - see `columnNativeType`.
+ *
+ * 3. Dialect gate: MySQL only
+ * ------------------------------
+ * `MODIFY` and the `JSON` type are MySQL's. A text-family `Data` on MSSQL
+ * (`nvarchar`) or sqlite (`TEXT`) passes guard 2 and would then be handed
+ * syntax its server rejects - the same failed-migration outage guard 2 exists to
+ * prevent. Those dialects keep a text column and the read path keeps decoding a
+ * string, which is exactly what `decodeSessionData` does with it.
+ *
+ * 4. The wipe
+ * -----------
+ * Reached only when an actual `text -> json` conversion is about to happen.
+ * MySQL validates EVERY existing row during that conversion, and a single
+ * malformed / truncated / empty payload (a row from a crashed write, a row
+ * written by an older codec, a row truncated by TEXT's 64 KiB limit) fails the
+ * statement:
+ *
+ *     ERROR 3140 (22032): Invalid JSON text: "Invalid value." at position 1
+ *
+ * Emptying the table first makes the conversion unconditionally safe. Sessions
+ * are disposable state: the worst a user sees is one forced re-login, and that
+ * is now paid ONLY by the deployments actually being converted - a fresh install
+ * skips at guard 2 and never deletes anything.
+ *
+ * `DELETE`, not `TRUNCATE`: truncate is not transactional, is refused outright
+ * by some engines for a table involved in foreign keys, and there is no volume
+ * here to make the difference worth having.
+ *
+ * 5. ONE statement, not three
+ * ----------------------------
+ * `alterTable()` compiles one `ICompilerOutput` per modified column and
+ * `SqlDriver.execute` wraps the array in `Promise.all` - three concurrent
+ * `ALTER TABLE`s on three pooled connections against one table. A partial
+ * failure leaves the table half-converted AND the migration marked failed. The
+ * raw escape hatch (`schema().raw`, compiled by `SqlRawSchemaQueryCompiler`,
+ * registered by every SQL driver via `orm-sql`) sends exactly one statement.
+ * The `CreatedAt`/`Expiration` widening that used to ride along here now lives
+ * in its own migration (`UserSessionTimestamps_2026_07_31_00_00_01`), because it
+ * is a cast that cannot fail and must stay independently applicable.
+ */
+let UserSessionDataJson_2026_07_31_00_00_00 = class UserSessionDataJson_2026_07_31_00_00_00 extends OrmMigration {
+    async up(connection) {
+        if (!(await connection.schema().tableExists('user_sessions'))) {
+            return;
+        }
+        const dataType = await columnNativeType(connection, 'user_sessions', 'Data');
+        // already `json` (fresh install / already converged), unreadable, or a type
+        // nobody anticipated - all three mean "leave it alone"
+        if (dataType === null || !isTextFamily(dataType)) {
+            return;
+        }
+        if (!isMySqlDialect(connection)) {
+            return;
+        }
+        await connection.schema().raw('DELETE FROM user_sessions');
+        // Identifiers are backtick-quoted: this statement is MySQL-only by
+        // construction (guard 3), so portability of the quoting style is not a
+        // constraint, and quoting removes any question about `Data` being a MySQL
+        // keyword. `NOT NULL` is restated because MODIFY replaces the WHOLE column
+        // definition - omitting it would silently make the column nullable.
+        await connection.schema().raw('ALTER TABLE `user_sessions` MODIFY `Data` JSON NOT NULL');
+    }
+    /**
+     * Restores the text column. The sessions `up()` deleted are gone for good -
+     * that part is not reversible and nothing pretends otherwise - but the SHAPE
+     * is, and a package rollback that leaves a `json` column behind for a
+     * `2.0.488` reader is its own outage.
+     *
+     * Guarded by the inverse probe: only a column that is currently `json` is
+     * touched, so running `down()` twice, or against a database this migration
+     * never converted, does nothing.
+     *
+     * `TEXT` because `TEXT` is what the deployed databases had. Note this is a
+     * NARROWING cast - a stored payload above TEXT's 64 KiB limit would fail the
+     * statement in strict mode. That is acceptable here in a way it would not be
+     * in `up()`: `down()` runs only on an explicit, interactive rollback, never at
+     * boot, so a failure is loud and immediate rather than an unbootable service.
+     */
+    async down(connection) {
+        if (!(await connection.schema().tableExists('user_sessions'))) {
+            return;
+        }
+        const dataType = await columnNativeType(connection, 'user_sessions', 'Data');
+        if (dataType !== 'json' || !isMySqlDialect(connection)) {
+            return;
+        }
+        await connection.schema().raw('ALTER TABLE `user_sessions` MODIFY `Data` TEXT NOT NULL');
+    }
+};
+UserSessionDataJson_2026_07_31_00_00_00 = __decorate([
+    Migration('session-provider-connection')
+], UserSessionDataJson_2026_07_31_00_00_00);
+export { UserSessionDataJson_2026_07_31_00_00_00 };
+//# sourceMappingURL=UserSessionDataJson_2026_07_31_00_00_00.js.map

package/lib/mjs/migrations/UserSessionDataJson_2026_07_31_00_00_00.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserSessionDataJson_2026_07_31_00_00_00.js","sourceRoot":"","sources":["../../../src/migrations/UserSessionDataJson_2026_07_31_00_00_00.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAa,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAEI,IAAM,uCAAuC,GAA7C,MAAM,uCAAwC,SAAQ,YAAY;IAChE,KAAK,CAAC,EAAE,CAAC,UAAqB;QACnC,IAAI,CAAC,CAAC,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC;YAC9D,OAAO;QACT,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,UAAU,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;QAE7E,4EAA4E;QAC5E,uDAAuD;QACvD,IAAI,QAAQ,KAAK,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjD,OAAO;QACT,CAAC;QAED,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,CAAC;YAChC,OAAO;QACT,CAAC;QAED,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAC;QAE3D,mEAAmE;QACnE,uEAAuE;QACvE,0EAA0E;QAC1E,2EAA2E;QAC3E,oEAAoE;QACpE,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,yDAAyD,CAAC,CAAC;IAC3F,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,KAAK,CAAC,IAAI,CAAC,UAAqB;QACrC,IAAI,CAAC,CAAC,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC;YAC9D,OAAO;QACT,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,UAAU,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;QAE7E,IAAI,QAAQ,KAAK,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,CAAC;YACvD,OAAO;QACT,CAAC;QAED,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,yDAAyD,CAAC,CAAC;IAC3F,CAAC;CACF,CAAA;AAzDY,uCAAuC;IADnD,SAAS,CAAC,6BAA6B,CAAC;GAC5B,uCAAuC,CAyDnD"}

package/lib/mjs/migrations/UserSessionTimestamps_2026_07_31_00_00_01.d.ts

@@ -0,0 +1,68 @@
+import { OrmMigration, OrmDriver } from '@spinajs/orm';
+/**
+ * Widens `user_sessions.CreatedAt` / `Expiration` from `date` to `datetime`.
+ *
+ * !! This is a correctness fix in its own right and has nothing to do with the
+ * JSON conversion it used to be bundled with. It is a separate migration
+ * precisely so it can be applied, skipped, reviewed and reverted on its own.
+ *
+ * The bug
+ * -------
+ * A MySQL `date` column stores only the calendar day - MySQL truncates the time
+ * component on write, silently:
+ *
+ *     INSERT INTO probe VALUES ('2026-07-31 23:45:12', '2026-07-31 23:45:12');
+ *     asDate       asDateTime
+ *     2026-07-31   2026-07-31 23:45:12
+ *
+ * So on a deployed database a session's `Expiration` has no time of day: a
+ * session created at 23:45 with a 60-minute sliding TTL, due to expire at
+ * 00:45:12, is stored as expiring at 00:00:00 and the cleanup sweep kills it
+ * ~45 minutes early. Sliding expiration, `SessionProvider.isExpired`,
+ * `cleanupExpired` and `touch` all operate on that truncated value. `DbSession`
+ * declares both fields as luxon `DateTime` and the create path has declared both
+ * as `dateTime` since 2024; `datetime` is the type the code has always assumed
+ * it had.
+ *
+ * Why this one is safe where the JSON one was not
+ * -----------------------------------------------
+ * `date -> datetime` is a WIDENING cast. Every existing value is representable
+ * in the target type (midnight of the stored day), so unlike the `text -> json`
+ * conversion it cannot fail on row content and needs no wipe. Nothing is
+ * deleted here.
+ *
+ * Guards mirror the JSON migration: skip when the table is absent, skip unless
+ * `CreatedAt` is currently exactly `date`, skip on any non-MySQL dialect
+ * (`MODIFY` is MySQL syntax; a failed migration at boot bricks every later
+ * migration on the connection through `assertNoFailed()`). `CreatedAt` alone is
+ * probed - the two columns were created by the same statement in every database
+ * that has the old shape, and a `date`/`datetime` split between them has never
+ * existed.
+ *
+ * ONE statement with two `MODIFY` clauses, via the raw escape hatch, rather than
+ * `alterTable()`: the builder compiles one statement per column and
+ * `SqlDriver.execute` runs them through `Promise.all`, i.e. two concurrent
+ * `ALTER TABLE`s on the same table from two pooled connections.
+ *
+ * Nullability is restated verbatim from the create path - `MODIFY` replaces the
+ * whole column definition, and `CreatedAt` is `notNull()` there while
+ * `Expiration` is nullable (a never-expiring session persists a NULL).
+ */
+export declare class UserSessionTimestamps_2026_07_31_00_00_01 extends OrmMigration {
+    up(connection: OrmDriver): Promise<void>;
+    /**
+     * Deliberately a no-op, and this is a decision rather than an omission.
+     *
+     * `up()` widened `date -> datetime`. Reversing it would be a NARROWING cast
+     * that silently truncates the time-of-day off every stored row - it destroys
+     * data, and it re-introduces the exact expiry bug this migration exists to
+     * fix, on a schema whose model and create path have declared `dateTime` for
+     * years. A `datetime` column is also perfectly readable by every version of
+     * this package, so a rollback has nothing to gain from shrinking it.
+     *
+     * (The JSON migration's `down()` is implemented, because there the old readers
+     * genuinely cannot cope with the new column type. That is not the case here.)
+     */
+    down(_connection: OrmDriver): Promise<void>;
+}
+//# sourceMappingURL=UserSessionTimestamps_2026_07_31_00_00_01.d.ts.map

package/lib/mjs/migrations/UserSessionTimestamps_2026_07_31_00_00_01.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserSessionTimestamps_2026_07_31_00_00_01.d.ts","sourceRoot":"","sources":["../../../src/migrations/UserSessionTimestamps_2026_07_31_00_00_01.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBACa,yCAA0C,SAAQ,YAAY;IAC5D,EAAE,CAAC,UAAU,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBrD;;;;;;;;;;;;OAYG;IAEU,IAAI,CAAC,WAAW,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CACzD"}

package/lib/mjs/migrations/UserSessionTimestamps_2026_07_31_00_00_01.js

@@ -0,0 +1,92 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+import { Migration, OrmMigration } from '@spinajs/orm';
+import { columnNativeType, isMySqlDialect } from '../migration-support.js';
+/**
+ * Widens `user_sessions.CreatedAt` / `Expiration` from `date` to `datetime`.
+ *
+ * !! This is a correctness fix in its own right and has nothing to do with the
+ * JSON conversion it used to be bundled with. It is a separate migration
+ * precisely so it can be applied, skipped, reviewed and reverted on its own.
+ *
+ * The bug
+ * -------
+ * A MySQL `date` column stores only the calendar day - MySQL truncates the time
+ * component on write, silently:
+ *
+ *     INSERT INTO probe VALUES ('2026-07-31 23:45:12', '2026-07-31 23:45:12');
+ *     asDate       asDateTime
+ *     2026-07-31   2026-07-31 23:45:12
+ *
+ * So on a deployed database a session's `Expiration` has no time of day: a
+ * session created at 23:45 with a 60-minute sliding TTL, due to expire at
+ * 00:45:12, is stored as expiring at 00:00:00 and the cleanup sweep kills it
+ * ~45 minutes early. Sliding expiration, `SessionProvider.isExpired`,
+ * `cleanupExpired` and `touch` all operate on that truncated value. `DbSession`
+ * declares both fields as luxon `DateTime` and the create path has declared both
+ * as `dateTime` since 2024; `datetime` is the type the code has always assumed
+ * it had.
+ *
+ * Why this one is safe where the JSON one was not
+ * -----------------------------------------------
+ * `date -> datetime` is a WIDENING cast. Every existing value is representable
+ * in the target type (midnight of the stored day), so unlike the `text -> json`
+ * conversion it cannot fail on row content and needs no wipe. Nothing is
+ * deleted here.
+ *
+ * Guards mirror the JSON migration: skip when the table is absent, skip unless
+ * `CreatedAt` is currently exactly `date`, skip on any non-MySQL dialect
+ * (`MODIFY` is MySQL syntax; a failed migration at boot bricks every later
+ * migration on the connection through `assertNoFailed()`). `CreatedAt` alone is
+ * probed - the two columns were created by the same statement in every database
+ * that has the old shape, and a `date`/`datetime` split between them has never
+ * existed.
+ *
+ * ONE statement with two `MODIFY` clauses, via the raw escape hatch, rather than
+ * `alterTable()`: the builder compiles one statement per column and
+ * `SqlDriver.execute` runs them through `Promise.all`, i.e. two concurrent
+ * `ALTER TABLE`s on the same table from two pooled connections.
+ *
+ * Nullability is restated verbatim from the create path - `MODIFY` replaces the
+ * whole column definition, and `CreatedAt` is `notNull()` there while
+ * `Expiration` is nullable (a never-expiring session persists a NULL).
+ */
+let UserSessionTimestamps_2026_07_31_00_00_01 = class UserSessionTimestamps_2026_07_31_00_00_01 extends OrmMigration {
+    async up(connection) {
+        if (!(await connection.schema().tableExists('user_sessions'))) {
+            return;
+        }
+        const createdAtType = await columnNativeType(connection, 'user_sessions', 'CreatedAt');
+        // Only the one known-bad state is converted. `datetime` is the target,
+        // `timestamp` needs no help, `null` means the probe could not read the
+        // table, and anything else is a shape this migration was not written for.
+        if (createdAtType !== 'date' || !isMySqlDialect(connection)) {
+            return;
+        }
+        await connection.schema().raw('ALTER TABLE `user_sessions` MODIFY `CreatedAt` DATETIME NOT NULL, MODIFY `Expiration` DATETIME');
+    }
+    /**
+     * Deliberately a no-op, and this is a decision rather than an omission.
+     *
+     * `up()` widened `date -> datetime`. Reversing it would be a NARROWING cast
+     * that silently truncates the time-of-day off every stored row - it destroys
+     * data, and it re-introduces the exact expiry bug this migration exists to
+     * fix, on a schema whose model and create path have declared `dateTime` for
+     * years. A `datetime` column is also perfectly readable by every version of
+     * this package, so a rollback has nothing to gain from shrinking it.
+     *
+     * (The JSON migration's `down()` is implemented, because there the old readers
+     * genuinely cannot cope with the new column type. That is not the case here.)
+     */
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    async down(_connection) { }
+};
+UserSessionTimestamps_2026_07_31_00_00_01 = __decorate([
+    Migration('session-provider-connection')
+], UserSessionTimestamps_2026_07_31_00_00_01);
+export { UserSessionTimestamps_2026_07_31_00_00_01 };
+//# sourceMappingURL=UserSessionTimestamps_2026_07_31_00_00_01.js.map

package/lib/mjs/migrations/UserSessionTimestamps_2026_07_31_00_00_01.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserSessionTimestamps_2026_07_31_00_00_01.js","sourceRoot":"","sources":["../../../src/migrations/UserSessionTimestamps_2026_07_31_00_00_01.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAa,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEI,IAAM,yCAAyC,GAA/C,MAAM,yCAA0C,SAAQ,YAAY;IAClE,KAAK,CAAC,EAAE,CAAC,UAAqB;QACnC,IAAI,CAAC,CAAC,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC;YAC9D,OAAO;QACT,CAAC;QAED,MAAM,aAAa,GAAG,MAAM,gBAAgB,CAAC,UAAU,EAAE,eAAe,EAAE,WAAW,CAAC,CAAC;QAEvF,uEAAuE;QACvE,uEAAuE;QACvE,0EAA0E;QAC1E,IAAI,aAAa,KAAK,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,CAAC;YAC5D,OAAO;QACT,CAAC;QAED,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,gGAAgG,CAAC,CAAC;IAClI,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,gEAAgE;IACzD,KAAK,CAAC,IAAI,CAAC,WAAsB,IAAkB,CAAC;CAC5D,CAAA;AAjCY,yCAAyC;IADrD,SAAS,CAAC,6BAA6B,CAAC;GAC5B,yCAAyC,CAiCrD"}

package/lib/mjs/models/DbSession.d.ts

@@ -4,6 +4,21 @@ export declare class DbSession extends ModelBase {
     SessionId: string;
     CreatedAt: DateTime;
     Expiration: DateTime;
+    /**
+     * Serialized session payload - see `encodeSessionData` / `decodeSessionData`.
+     *
+     * Declared as a string because that is what the WRITE path assigns:
+     * `encodeSessionData` produces JSON text and a MySQL `json` column stores it
+     * verbatim. What comes BACK depends on the driver - mysql2 parses a json
+     * column into an object, sqlite returns the text - so the read path accepts
+     * both. The declared type is deliberately not widened to `string | object`:
+     * this model is exported, the object shape never escapes the provider, and
+     * widening would force every consumer to narrow for a case it cannot observe.
+     *
+     * No `@Json()` decorator on purpose: the ORM's JsonValueConverter would
+     * `JSON.stringify` the already-encoded string on write and double-encode
+     * every session.
+     */
     Data: string;
     UserId: number;
 }

package/lib/mjs/models/DbSession.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DbSession.d.ts","sourceRoot":"","sources":["../../../src/models/DbSession.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAyD,MAAM,cAAc,CAAC;AAChG,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,qBAEa,SAAU,SAAQ,SAAS;IAE/B,SAAS,EAAE,MAAM,CAAC;IAGlB,SAAS,EAAE,QAAQ,CAAC;IAGpB,UAAU,EAAE,QAAQ,CAAC;IAErB,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,EAAE,MAAM,CAAC;CACvB"}
+{"version":3,"file":"DbSession.d.ts","sourceRoot":"","sources":["../../../src/models/DbSession.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAyD,MAAM,cAAc,CAAC;AAChG,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,qBAEa,SAAU,SAAQ,SAAS;IAE/B,SAAS,EAAE,MAAM,CAAC;IAGlB,SAAS,EAAE,QAAQ,CAAC;IAGpB,UAAU,EAAE,QAAQ,CAAC;IAE5B;;;;;;;;;;;;;;OAcG;IACI,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,EAAE,MAAM,CAAC;CACvB"}

package/lib/mjs/models/DbSession.js.map

@@ -1 +1 @@
-{"version":3,"file":"DbSession.js","sourceRoot":"","sources":["../../../src/models/DbSession.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,cAAc,CAAC;AAChG,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAG1B,IAAM,SAAS,GAAf,MAAM,SAAU,SAAQ,SAAS;CAavC,CAAA;AAXQ;IADN,OAAO,EAAE;;4CACe;AAGlB;IADN,SAAS,EAAE;8BACM,QAAQ;4CAAC;AAGpB;IADN,EAAE,EAAE;8BACc,QAAQ;6CAAC;AARjB,SAAS;IAFrB,UAAU,CAAC,6BAA6B,CAAC;IACzC,KAAK,CAAC,eAAe,CAAC;GACV,SAAS,CAarB"}
+{"version":3,"file":"DbSession.js","sourceRoot":"","sources":["../../../src/models/DbSession.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,cAAc,CAAC;AAChG,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAG1B,IAAM,SAAS,GAAf,MAAM,SAAU,SAAQ,SAAS;CA4BvC,CAAA;AA1BQ;IADN,OAAO,EAAE;;4CACe;AAGlB;IADN,SAAS,EAAE;8BACM,QAAQ;4CAAC;AAGpB;IADN,EAAE,EAAE;8BACc,QAAQ;6CAAC;AARjB,SAAS;IAFrB,UAAU,CAAC,6BAA6B,CAAC;IACzC,KAAK,CAAC,eAAe,CAAC;GACV,SAAS,CA4BrB"}