@tstdl/base 0.92.166 → 0.92.168

package/lock/lock.d.ts

@@ -1,25 +1,24 @@
+import type { CancellationSignal } from '../cancellation/index.js';
 import type { Resolvable } from '../injector/index.js';
 import { resolveArgumentType } from '../injector/index.js';
-export type LockedFunction<R> = (controller: LockController) => R | Promise<R>;
-export type AcquireResult<Throw extends boolean> = Throw extends true ? LockController : (LockController | false);
-export type UsingResult<Throw extends boolean, R> = Throw extends true ? ({
+export type LockedFunction<R> = (controller: UseLockController) => R | Promise<R>;
+export type LockTryUseResult<R> = ({
     success: true;
     result: R;
-}) : ({
-    success: true;
-    result: R;
-} | {
+}) | ({
     success: false;
-    result: undefined;
+    result?: undefined;
 });
-export interface LockController {
+export interface UseLockController {
     /**
-     * whether the the lock is lost or not. Can happen for example if it couldn't be renewed
+     * Whether the the lock is lost or not. Can happen for example if it couldn't be renewed
      * because the network connection is lost (depending on implementation)
      */
     readonly lost: boolean;
+}
+export interface LockController extends UseLockController {
     /** manually release lock */
-    release(): void | Promise<void>;
+    release(): Promise<void>;
 }
 /** resource */
 export type LockArgument = string | {
@@ -27,22 +26,42 @@ export type LockArgument = string | {
     resource: string;
 };
 export declare abstract class Lock implements Resolvable<LockArgument> {
+    protected readonly cancellationSignal: CancellationSignal;
     readonly resource: string;
     readonly [resolveArgumentType]: LockArgument;
-    constructor(resource: string);
+    constructor(resource: string, cancellationSignal: CancellationSignal);
+    /**
+     * Tries to acquire a lock for the resource, it must be manually released.
+     * @param timeout How long to try to get a lock in milliseconds. If undefined, it tries only once.
+     * @returns A lock controller if successful, otherwise `false`.
+     */
+    tryAcquire(timeout?: number): Promise<LockController | false>;
+    /**
+     * Acquires a lock for the resource, it must be manually released.
+     * Throws an error if the lock cannot be acquired within the specified timeout.
+     * @param timeout How long to try to get a lock in milliseconds. If undefined, it tries forever.
+     */
+    acquire(timeout?: number): Promise<LockController>;
+    /**
+     * Tries to acquire a lock for the resource and releases it automatically after the provided function has returned or thrown.
+     * @param timeout How long to try to get a lock in milliseconds. If undefined, it tries only once.
+     * @param func Function to run when the lock is acquired.
+     * @returns A result object indicating success and containing the return value of the function.
+     */
+    tryUse<R>(timeout: number | undefined, func: LockedFunction<R>): Promise<LockTryUseResult<R>>;
     /**
-     * acquire a lock for the resource, it must be manually released
-     * @param timeout how long to try to get a lock. If undefined it's tries forever
-     * @param throwOnFail throw if resource is locked and we couldn't acquire it in the specified timeout
+     * Acquires a lock for the resource and releases it automatically after the provided function has returned or thrown.
+     * Throws an error if the lock cannot be acquired within the specified timeout.
+     * @param timeout How long to try to get a lock in milliseconds. If undefined, it tries forever.
+     * @param func Function to run when the lock is acquired.
+     * @returns The return value of the function.
      */
-    abstract acquire<Throw extends boolean>(timeout: number | undefined, throwOnFail: Throw): Promise<AcquireResult<Throw>>;
+    use<R>(timeout: number | undefined, func: LockedFunction<R>): Promise<R>;
     /**
-     * acquire a lock for the resource and release it automatically after the provided function has returned or thrown
-     * @param timeout how long to try to get a lock. If undefined it's tries forever
-     * @param throwOnFail throw if resource is locked and we couldn't acquire it in the specified timeout
-     * @param func function to run when lock is acquired
+     * try to acquire the lock for the resource, returns a controller if successful
+     * returns false if the lock is already held by another process
      */
-    abstract use<Throw extends boolean, R>(timeout: number | undefined, throwOnFail: Throw, func: LockedFunction<R>): Promise<UsingResult<Throw, R>>;
+    abstract tryAcquireOnce(): Promise<LockController | false>;
     /** check if resource is locked */
     abstract exists(): Promise<boolean>;
 }

package/lock/lock.js

@@ -1,7 +1,80 @@
 import { resolveArgumentType } from '../injector/index.js';
+import { Timer } from '../utils/timer.js';
+import { cancelableTimeout } from '../utils/timing.js';
+import { isUndefined } from '../utils/type-guards.js';
 export class Lock {
+    cancellationSignal;
     resource;
-    constructor(resource) {
+    constructor(resource, cancellationSignal) {
+        this.cancellationSignal = cancellationSignal;
         this.resource = resource;
     }
+    /**
+     * Tries to acquire a lock for the resource, it must be manually released.
+     * @param timeout How long to try to get a lock in milliseconds. If undefined, it tries only once.
+     * @returns A lock controller if successful, otherwise `false`.
+     */
+    async tryAcquire(timeout) {
+        if (isUndefined(timeout) || (timeout <= 0)) {
+            return await this.tryAcquireOnce();
+        }
+        const delay = Math.max(50, Math.min(1000, timeout / 10));
+        const timer = new Timer(true);
+        do {
+            const result = await this.tryAcquireOnce();
+            if (result !== false) {
+                return result;
+            }
+            const delayResult = await cancelableTimeout(delay, this.cancellationSignal);
+            if (delayResult == 'canceled') {
+                break;
+            }
+        } while (timer.milliseconds < timeout);
+        return false;
+    }
+    /**
+     * Acquires a lock for the resource, it must be manually released.
+     * Throws an error if the lock cannot be acquired within the specified timeout.
+     * @param timeout How long to try to get a lock in milliseconds. If undefined, it tries forever.
+     */
+    async acquire(timeout) {
+        const result = await this.tryAcquire(timeout);
+        if (result === false) {
+            throw new Error(`Failed to acquire lock for resource '${this.resource}'.`);
+        }
+        return result;
+    }
+    /**
+     * Tries to acquire a lock for the resource and releases it automatically after the provided function has returned or thrown.
+     * @param timeout How long to try to get a lock in milliseconds. If undefined, it tries only once.
+     * @param func Function to run when the lock is acquired.
+     * @returns A result object indicating success and containing the return value of the function.
+     */
+    async tryUse(timeout, func) {
+        const controller = await this.tryAcquire(timeout);
+        if (controller == false) {
+            return { success: false, result: undefined };
+        }
+        try {
+            const result = await func(controller);
+            return { success: true, result };
+        }
+        finally {
+            await controller.release();
+        }
+    }
+    /**
+     * Acquires a lock for the resource and releases it automatically after the provided function has returned or thrown.
+     * Throws an error if the lock cannot be acquired within the specified timeout.
+     * @param timeout How long to try to get a lock in milliseconds. If undefined, it tries forever.
+     * @param func Function to run when the lock is acquired.
+     * @returns The return value of the function.
+     */
+    async use(timeout, func) {
+        const result = await this.tryUse(timeout, func);
+        if (!result.success) {
+            throw new Error(`Failed to acquire lock for resource '${this.resource}'.`);
+        }
+        return result.result;
+    }
 }

package/lock/postgres/drizzle/0000_busy_tattoo.sql

@@ -0,0 +1,7 @@
+CREATE TABLE "lock"."lock" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"resource" text NOT NULL,
+	"key" text NOT NULL,
+	"expiration" timestamp with time zone NOT NULL,
+	CONSTRAINT "lock_resource_unique" UNIQUE("resource")
+);

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>;
 }