@tstdl/base 0.92.167 → 0.93.0

package/lock/postgres/drizzle/meta/0000_snapshot.json

@@ -0,0 +1,65 @@
+{
+  "id": "2d26f59a-2c92-4d3c-aea3-93aa48a91d5f",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "lock.lock": {
+      "name": "lock",
+      "schema": "lock",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "resource": {
+          "name": "resource",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expiration": {
+          "name": "expiration",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "lock_resource_unique": {
+          "name": "lock_resource_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "resource"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/lock/postgres/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1756898177209,
+      "tag": "0000_busy_tattoo",
+      "breakpoints": true
+    }
+  ]
+}

package/lock/postgres/drizzle.config.js

@@ -0,0 +1,11 @@
+import { relative, resolve } from 'node:path';
+import { defineConfig } from 'drizzle-kit';
+export default defineConfig({
+    dialect: 'postgresql',
+    out: relative('./', resolve(__dirname, './drizzle/').replace('dist', 'source')),
+    schema: resolve(__dirname, './models/schemas.js'),
+    migrations: {
+        schema: 'lock',
+        table: '_migrations',
+    },
+});

package/lock/postgres/index.d.ts

@@ -0,0 +1,2 @@
+export * from './provider.js';
+export * from './module.js';

package/lock/postgres/index.js

@@ -0,0 +1,2 @@
+export * from './provider.js';
+export * from './module.js';

package/lock/postgres/lock.d.ts

@@ -0,0 +1,14 @@
+import { type CancellationSignal } from '../../cancellation/index.js';
+import type { Logger } from '../../logger/logger.js';
+import type { EntityRepository } from '../../orm/server/index.js';
+import { Lock, type LockController } from '../lock.js';
+import type { PostgresLock } from './models/lock.model.js';
+export declare class PostgresLockAdapter extends Lock {
+    #private;
+    constructor(repository: EntityRepository<PostgresLock>, resource: string, logger: Logger, cancellationSignal: CancellationSignal);
+    tryAcquireOnce(): Promise<LockController | false>;
+    exists(): Promise<boolean>;
+    private executeTryAcquire;
+    private tryRefresh;
+    private release;
+}

package/lock/postgres/lock.js

@@ -0,0 +1,127 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { and, eq, lte, sql } from 'drizzle-orm';
+import { CancellationToken } from '../../cancellation/index.js';
+import { Injectable } from '../../injector/decorators.js';
+import { TRANSACTION_TIMESTAMP } from '../../orm/sqls.js';
+import { currentTimestamp } from '../../utils/date-time.js';
+import { cancelableTimeoutUntil } from '../../utils/timing.js';
+import { assertDefined, isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+import { Lock } from '../lock.js';
+import { lock } from './models/schemas.js';
+import { PostgresLockProvider } from './provider.js';
+const expirationTime = 10000;
+const renewBuffer = expirationTime / 2;
+let PostgresLockAdapter = class PostgresLockAdapter extends Lock {
+    #lockRepository;
+    #logger;
+    constructor(repository, resource, logger, cancellationSignal) {
+        super(resource, cancellationSignal);
+        this.#lockRepository = repository;
+        this.#logger = logger;
+    }
+    async tryAcquireOnce() {
+        const key = crypto.randomUUID();
+        let result = await this.executeTryAcquire(this.resource, key);
+        if (result === false) {
+            return false;
+        }
+        const releaseToken = new CancellationToken();
+        let expiration = result;
+        const controller = {
+            get lost() {
+                return currentTimestamp() >= expiration;
+            },
+            release: async () => {
+                releaseToken.set();
+                await this.release(this.resource, key);
+            },
+        };
+        void (async () => {
+            await cancelableTimeoutUntil(expiration - renewBuffer, releaseToken);
+            while (!releaseToken.isSet && !controller.lost) {
+                try {
+                    const refreshResult = await this.tryRefresh(this.resource, key);
+                    expiration = (refreshResult === false) ? 0 : refreshResult;
+                }
+                catch (error) {
+                    this.#logger.error(error);
+                }
+                finally {
+                    await cancelableTimeoutUntil(Math.max(currentTimestamp() + 1000, expiration - renewBuffer), releaseToken);
+                }
+            }
+        })();
+        return controller;
+    }
+    async exists() {
+        return await this.#lockRepository.hasByQuery({
+            resource: this.resource,
+            expiration: { $gt: TRANSACTION_TIMESTAMP },
+        });
+    }
+    async executeTryAcquire(resource, key) {
+        const upsertQuery = this.#lockRepository.session
+            .insert(lock)
+            .values({
+            resource,
+            key,
+            expiration: sql `${TRANSACTION_TIMESTAMP} + INTERVAL '${sql.raw(expirationTime.toString())} milliseconds'`,
+        })
+            .onConflictDoUpdate({
+            target: this.#lockRepository.getColumn('resource'),
+            set: {
+                key: sql.raw(`excluded.${lock.key.name}`),
+                expiration: sql.raw(`excluded.${lock.expiration.name}`),
+            },
+            setWhere: lte(lock.expiration, TRANSACTION_TIMESTAMP),
+        })
+            .returning({ expiration: lock.expiration });
+        console.log(upsertQuery.toSQL());
+        const [result] = await upsertQuery;
+        if (isUndefined(result)) {
+            return false;
+        }
+        return result.expiration;
+    }
+    async tryRefresh(resource, key) {
+        const [result] = await this.#lockRepository.session
+            .update(lock)
+            .set({
+            expiration: sql `${TRANSACTION_TIMESTAMP} + INTERVAL '${sql.raw(expirationTime.toString())} milliseconds'`,
+        })
+            .where(and(eq(lock.resource, resource), eq(lock.key, key)))
+            .returning({ expiration: lock.expiration });
+        if (isUndefined(result)) {
+            return false;
+        }
+        return result.expiration;
+    }
+    async release(resource, key) {
+        const result = await this.#lockRepository.tryDeleteByQuery({ resource, key });
+        return isDefined(result);
+    }
+};
+PostgresLockAdapter = __decorate([
+    Injectable({
+        lifecycle: 'transient', provider: {
+            useFactory: (argument, context) => {
+                assertDefined(argument, 'Missing argument for lock.');
+                const argumentIsString = isString(argument);
+                const prefix = argumentIsString ? undefined : argument.prefix;
+                const resource = argumentIsString ? argument : argument.resource;
+                const provider = context.resolve(PostgresLockProvider, prefix);
+                return provider.get(resource);
+            },
+        },
+    }),
+    __metadata("design:paramtypes", [Function, String, Function, Function])
+], PostgresLockAdapter);
+export { PostgresLockAdapter };

package/lock/postgres/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lock.model.js';
+export * from './schemas.js';

package/lock/postgres/models/index.js

@@ -0,0 +1,2 @@
+export * from './lock.model.js';
+export * from './schemas.js';

package/lock/postgres/models/lock.model.d.ts

@@ -0,0 +1,7 @@
+import { EntityWithoutMetadata } from '../../../orm/entity.js';
+import { Timestamp } from '../../../orm/types.js';
+export declare class PostgresLock extends EntityWithoutMetadata {
+    resource: string;
+    key: string;
+    expiration: Timestamp;
+}

package/{examples/orm/user.model.js → lock/postgres/models/lock.model.js}

@@ -7,38 +7,30 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Array, Entity, Integer, Unique } from '../../orm/index.js';
-import { BooleanProperty, StringProperty } from '../../schema/index.js';
-export var Foo;
-(function (Foo) {
-    Foo[Foo["Bar"] = 0] = "Bar";
-    Foo[Foo["Baz"] = 1] = "Baz";
-})(Foo || (Foo = {}));
-export class User extends Entity {
-    static entityName = 'User';
-    name;
-    nickNames;
-    age;
-    hasAge;
-    mail;
-}
+import { ExpiresAt, Table } from '../../../orm/decorators.js';
+import { EntityWithoutMetadata } from '../../../orm/entity.js';
+import { Timestamp, Unique } from '../../../orm/types.js';
+import { StringProperty } from '../../../schema/index.js';
+let PostgresLock = class PostgresLock extends EntityWithoutMetadata {
+    resource;
+    key;
+    expiration;
+};
 __decorate([
+    Unique(),
     StringProperty(),
     __metadata("design:type", String)
-], User.prototype, "name", void 0);
-__decorate([
-    Array(String),
-    __metadata("design:type", Array)
-], User.prototype, "nickNames", void 0);
-__decorate([
-    Integer({ nullable: true }),
-    __metadata("design:type", Object)
-], User.prototype, "age", void 0);
+], PostgresLock.prototype, "resource", void 0);
 __decorate([
-    BooleanProperty(),
-    __metadata("design:type", Boolean)
-], User.prototype, "hasAge", void 0);
-__decorate([
-    Unique(),
+    StringProperty(),
     __metadata("design:type", String)
-], User.prototype, "mail", void 0);
+], PostgresLock.prototype, "key", void 0);
+__decorate([
+    ExpiresAt(),
+    Timestamp(),
+    __metadata("design:type", Number)
+], PostgresLock.prototype, "expiration", void 0);
+PostgresLock = __decorate([
+    Table('lock')
+], PostgresLock);
+export { PostgresLock };

package/lock/postgres/models/schemas.d.ts

@@ -0,0 +1,3 @@
+import { PostgresLock } from './lock.model.js';
+export declare const lockSchema: import("../../../orm/server/database-schema.js").DatabaseSchema<"lock">;
+export declare const lock: import("../../../orm/server/types.js").PgTableFromType<typeof PostgresLock, "lock">;

package/lock/postgres/models/schemas.js

@@ -0,0 +1,4 @@
+import { databaseSchema } from '../../../orm/server/database-schema.js';
+import { PostgresLock } from './lock.model.js';
+export const lockSchema = databaseSchema('lock');
+export const lock = lockSchema.getTable(PostgresLock);

package/lock/postgres/module.d.ts

@@ -0,0 +1,6 @@
+import { type DatabaseConfig } from '../../orm/server/index.js';
+export declare class PostgresLockModuleConfig {
+    database?: DatabaseConfig;
+}
+export declare function configurePostgresLock(config?: PostgresLockModuleConfig): void;
+export declare function migratePostgresLockSchema(): Promise<void>;

package/lock/postgres/module.js

@@ -0,0 +1,26 @@
+import { inject, Injector } from '../../injector/index.js';
+import { Database, migrate } from '../../orm/server/index.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { Lock } from '../lock.js';
+import { LockProvider } from '../provider.js';
+import { PostgresLockProvider } from './provider.js';
+import { PostgresLockAdapter } from './lock.js';
+export class PostgresLockModuleConfig {
+    database;
+}
+export function configurePostgresLock(config) {
+    if (isDefined(config)) {
+        Injector.register(PostgresLockModuleConfig, { useValue: config });
+    }
+    Injector.registerSingleton(LockProvider, { useToken: PostgresLockProvider });
+    Injector.registerSingleton(Lock, { useToken: PostgresLockAdapter });
+}
+export async function migratePostgresLockSchema() {
+    const connection = inject(PostgresLockModuleConfig, undefined, { optional: true })?.database?.connection;
+    const database = inject(Database, connection);
+    await migrate(database, {
+        migrationsSchema: 'lock',
+        migrationsTable: '_migrations',
+        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+    });
+}

package/lock/postgres/provider.d.ts

@@ -0,0 +1,6 @@
+import type { Lock } from '../lock.js';
+import { LockProvider } from '../provider.js';
+export declare class PostgresLockProvider extends LockProvider {
+    #private;
+    get(resource: string): Lock;
+}

package/lock/postgres/provider.js

@@ -0,0 +1,29 @@
+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 { Singleton, provide } from '../../injector/index.js';
+import { DatabaseConfig } from '../../orm/server/index.js';
+import { EntityRepositoryConfig, injectRepository } from '../../orm/server/repository.js';
+import { LockProvider } from '../provider.js';
+import { PostgresLockAdapter } from './lock.js';
+import { PostgresLock } from './models/lock.model.js';
+import { PostgresLockModuleConfig } from './module.js';
+let PostgresLockProvider = class PostgresLockProvider extends LockProvider {
+    #lockRepository = injectRepository(PostgresLock);
+    get(resource) {
+        const resourceString = this.getResourceString(resource, this._prefix);
+        return new PostgresLockAdapter(this.#lockRepository, resourceString, this.logger, this.cancellationSignal);
+    }
+};
+PostgresLockProvider = __decorate([
+    Singleton({
+        providers: [
+            provide(EntityRepositoryConfig, { useValue: { schema: 'lock' } }),
+            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresLockModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) },
+        ],
+    })
+], PostgresLockProvider);
+export { PostgresLockProvider };

package/lock/provider.d.ts

@@ -1,10 +1,20 @@
+import { CancellationSignal } from '../cancellation/index.js';
 import type { Resolvable } from '../injector/index.js';
-import { resolveArgumentType } from '../injector/index.js';
+import { Injector, resolveArgumentType } from '../injector/index.js';
+import { Logger } from '../logger/logger.js';
 import type { Lock } from './lock.js';
 /** prefix */
 export type LockProviderArgument = string;
 export declare abstract class LockProvider implements Resolvable<LockProviderArgument> {
+    #private;
+    protected readonly _prefix: string | undefined;
+    protected readonly injector: Injector;
+    protected readonly lockInjector: Injector;
+    protected readonly logger: Logger;
+    protected readonly cancellationSignal: CancellationSignal;
     readonly [resolveArgumentType]: LockProviderArgument;
-    abstract prefix(prefix: string): LockProvider;
+    constructor();
+    prefix(prefix: string): this;
     abstract get(resource: string): Lock;
+    protected getResourceString(resource: string, prefix?: string): string;
 }

package/lock/provider.js

@@ -1,3 +1,26 @@
-import { resolveArgumentType } from '../injector/index.js';
+import { CancellationSignal } from '../cancellation/index.js';
+import { inject, injectArgument, Injector, resolveArgumentType } from '../injector/index.js';
+import { Logger } from '../logger/logger.js';
+import { isDefined, isString } from '../utils/type-guards.js';
 export class LockProvider {
+    #type;
+    _prefix = injectArgument(this, { optional: true });
+    injector = inject(Injector);
+    lockInjector = this.injector.fork(`LockInjector${isString(this._prefix) ? `:${this._prefix}` : ''}`);
+    logger;
+    cancellationSignal = inject(CancellationSignal);
+    constructor() {
+        this.#type = new.target;
+        this.logger = inject(Logger, `${this.#type.name}${isString(this._prefix) ? `:${this._prefix}` : ''}`);
+    }
+    prefix(prefix) {
+        const newPrefixString = this.getResourceString(prefix, this._prefix);
+        return this.injector.resolve(this.#type, newPrefixString);
+    }
+    getResourceString(resource, prefix) {
+        if (isDefined(prefix) && (prefix.length > 0)) {
+            return `${prefix}:${resource}`;
+        }
+        return resource;
+    }
 }

package/lock/web/web-lock.d.ts

@@ -1,7 +1,8 @@
-import type { AcquireResult, LockedFunction, UsingResult } from '../lock.js';
+import type { LockController, LockedFunction, LockTryUseResult } from '../lock.js';
 import { Lock } from '../lock.js';
 export declare class WebLock extends Lock {
-    acquire<Throw extends boolean>(timeout: number | undefined, throwOnFail: Throw): Promise<AcquireResult<Throw>>;
-    use<Throw extends boolean, R>(timeout: number | undefined, throwOnFail: Throw, func: LockedFunction<R>): Promise<UsingResult<Throw, R>>;
+    tryAcquireOnce(): Promise<LockController | false>;
+    tryAcquire(timeout?: number): Promise<LockController | false>;
+    tryUse<R>(timeout: number | undefined, func: LockedFunction<R>): Promise<LockTryUseResult<R>>;
     exists(): Promise<boolean>;
 }

package/lock/web/web-lock.js

@@ -4,61 +4,68 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { map, timer } from 'rxjs';
-import { CancellationToken } from '../../cancellation/index.js';
 import { Injectable } from '../../injector/index.js';
 import { DeferredPromise } from '../../promise/deferred-promise.js';
-import { assertStringPass, isDefined, isNull, isObject } from '../../utils/type-guards.js';
+import { assertStringPass, isNull, isObject, isUndefined } from '../../utils/type-guards.js';
 import { Lock } from '../lock.js';
 import { WebLockProvider } from './web-lock.provider.js';
 let WebLock = class WebLock extends Lock {
-    async acquire(timeout, throwOnFail) {
-        const acquirePromise = new DeferredPromise();
+    async tryAcquireOnce() {
+        return await this.tryAcquire(0);
+    }
+    async tryAcquire(timeout) {
+        const controllerPromise = new DeferredPromise();
         const releasePromise = new DeferredPromise();
-        const controller = {
-            lost: false,
-            release() {
-                releasePromise.resolve();
-            },
-        };
-        const timeoutToken = (isDefined(timeout) && (timeout > 0)) ? CancellationToken.from(timer(timeout).pipe(map(() => true))) : undefined;
-        void navigator.locks.request(this.resource, {
-            signal: isDefined(timeoutToken) ? timeoutToken.asAbortSignal() : undefined,
-            ifAvailable: isDefined(timeout) && (timeout <= 0),
-        }, async (lock) => {
+        const ifAvailable = isUndefined(timeout) || (timeout <= 0);
+        const signal = ifAvailable ? undefined : AbortSignal.any([AbortSignal.timeout(timeout), this.cancellationSignal.asAbortSignal()]);
+        await navigator.locks
+            .request(this.resource, { signal, ifAvailable }, async (lock) => {
             if (isNull(lock)) {
-                acquirePromise.resolve(false);
-                return;
+                throw new Error('Failed to acquire lock.');
             }
-            acquirePromise.resolve(true);
+            let lost = false;
+            controllerPromise.resolve({
+                get lost() {
+                    return lost;
+                },
+                async release() {
+                    releasePromise.resolve();
+                },
+            });
             await releasePromise;
+            lost = true;
         })
-            .catch((error) => acquirePromise.reject(error));
-        try {
-            const success = await acquirePromise;
-            if (!success) {
-                throw new Error('Failed to acquire lock.');
-            }
-            return controller;
-        }
-        catch (error) {
-            if (throwOnFail) {
-                throw error;
-            }
-            return false;
-        }
+            .catch(() => controllerPromise.resolve(false));
+        return await controllerPromise;
     }
-    async use(timeout, throwOnFail, func) {
-        const controller = await this.acquire(timeout, throwOnFail);
-        if (controller == false) {
-            return { success: false, result: undefined };
-        }
+    async tryUse(timeout, func) {
+        const ifAvailable = isUndefined(timeout) || (timeout <= 0);
+        const signal = ifAvailable ? undefined : AbortSignal.any([AbortSignal.timeout(timeout), this.cancellationSignal.asAbortSignal()]);
+        let result;
         try {
-            const result = await func(controller);
-            return { success: true, result };
+            result = await navigator.locks.request(this.resource, { signal, ifAvailable }, async (lock) => {
+                if (isNull(lock)) {
+                    return { type: 'already-locked' };
+                }
+                try {
+                    const returnValue = await func({ lost: false });
+                    return { type: 'result', value: returnValue };
+                }
+                catch (error) {
+                    return { type: 'error', error };
+                }
+            });
+        }
+        catch {
+            return { success: false }; // navigator.locks.request throws a DOMException on timeout
         }
-        finally {
-            await controller.release();
+        switch (result.type) {
+            case 'result':
+                return { success: true, result: result.value };
+            case 'already-locked':
+                return { success: false };
+            case 'error':
+                throw result.error;
         }
     }
     async exists() {

package/lock/web/web-lock.provider.d.ts

@@ -1,8 +1,5 @@
 import type { Lock } from '../../lock/index.js';
 import { LockProvider } from '../../lock/index.js';
 export declare class WebLockProvider extends LockProvider {
-    private readonly _prefix;
-    constructor(prefix?: string);
-    prefix(prefix: string): LockProvider;
     get(resource: string): Lock;
 }

package/lock/web/web-lock.provider.js

@@ -4,32 +4,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-var WebLockProvider_1;
-import { InjectArg, Singleton } from '../../injector/index.js';
+import { Singleton } from '../../injector/index.js';
 import { LockProvider } from '../../lock/index.js';
 import { WebLock } from './web-lock.js';
-let WebLockProvider = WebLockProvider_1 = class WebLockProvider extends LockProvider {
-    _prefix;
-    constructor(prefix = '') {
-        super();
-        this._prefix = prefix;
-    }
-    prefix(prefix) {
-        return new WebLockProvider_1(this._prefix + prefix);
-    }
+let WebLockProvider = class WebLockProvider extends LockProvider {
     get(resource) {
-        return new WebLock(this._prefix + resource);
+        return new WebLock(this.getResourceString(resource, this._prefix), this.cancellationSignal);
     }
 };
-WebLockProvider = WebLockProvider_1 = __decorate([
-    Singleton(),
-    __param(0, InjectArg()),
-    __metadata("design:paramtypes", [String])
+WebLockProvider = __decorate([
+    Singleton()
 ], WebLockProvider);
 export { WebLockProvider };

package/logger/formatter.d.ts

@@ -0,0 +1,13 @@
+import type { Record } from '../types/types.js';
+import type { LogLevel } from './level.js';
+export type LogPayload = {
+    timestamp: Date;
+    level: LogLevel;
+    module: string[];
+    message: string;
+    context: Record<string>;
+};
+/** Formats a log payload for a transport. */
+export declare abstract class LogFormatter {
+    abstract format(payload: LogPayload): string;
+}

package/logger/formatter.js

@@ -0,0 +1,3 @@
+/** Formats a log payload for a transport. */
+export class LogFormatter {
+}