libmodulor 0.1.0 → 0.2.0

package/dist/esm/std/impl/EnvSettingsManager.js

@@ -0,0 +1,108 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var EnvSettingsManager_1;
+import { inject, injectable } from 'inversify';
+import { SettingsManagerMandatoryPlaceholder, SettingsManagerMandatoryPlaceholderForArray, SettingsManagerMandatoryPlaceholderForObject, } from '../SettingsManager.js';
+let EnvSettingsManager = class EnvSettingsManager {
+    static { EnvSettingsManager_1 = this; }
+    environmentManager;
+    settings;
+    static ENV_VAR_PREFIX = 'app_';
+    constructor(environmentManager, settings) {
+        this.environmentManager = environmentManager;
+        this.settings = settings;
+        const initializationErrors = Object.keys(settings)
+            .map((key) => {
+            try {
+                this.get()(key);
+                return null;
+            }
+            catch (err) {
+                return err.message;
+            }
+        })
+            .filter((message) => !!message);
+        if (initializationErrors.length > 0) {
+            throw new Error(`Initialization failed for the following reasons : ${initializationErrors.join(', ')}`);
+        }
+    }
+    get() {
+        return (key) => {
+            const envVarName = `${EnvSettingsManager_1.ENV_VAR_PREFIX}${key.toString()}`;
+            const envValue = this.environmentManager.env(envVarName);
+            const defaultValue = this.settings[key];
+            if (this.isMandatoryPlaceholder(defaultValue) &&
+                envValue === undefined) {
+                throw new Error(`Env var ${envVarName} must be defined`);
+            }
+            if (envValue === undefined) {
+                return defaultValue;
+            }
+            if (Array.isArray(defaultValue)) {
+                return JSON.parse(envValue);
+            }
+            if (typeof defaultValue === 'object' && defaultValue !== null) {
+                return JSON.parse(envValue);
+            }
+            if (typeof defaultValue === 'number') {
+                if (defaultValue.toString().includes('.')) {
+                    const envValueAsFloat = Number.parseFloat(envValue);
+                    if (Number.isNaN(envValueAsFloat)) {
+                        throw new Error(`Env var ${envVarName} must be a valid decimal number`);
+                    }
+                    return envValueAsFloat;
+                }
+                const envValueAsInt = Number.parseInt(envValue, 10);
+                if (Number.isNaN(envValueAsInt)) {
+                    throw new Error(`Env var ${envVarName} must be a valid integer`);
+                }
+                return envValueAsInt;
+            }
+            if (typeof defaultValue === 'boolean') {
+                if (['0', 'false'].includes(envValue)) {
+                    return false;
+                }
+                if (['1', 'true'].includes(envValue)) {
+                    return true;
+                }
+            }
+            return envValue;
+        };
+    }
+    isMandatoryPlaceholder(value) {
+        const mandatoryPlaceholder = SettingsManagerMandatoryPlaceholder;
+        if (value === null || value === undefined) {
+            return false;
+        }
+        const isSimpleString = value === mandatoryPlaceholder;
+        if (isSimpleString) {
+            return true;
+        }
+        const isArray = Array.isArray(value) &&
+            JSON.stringify(value) ===
+                JSON.stringify(SettingsManagerMandatoryPlaceholderForArray);
+        if (isArray) {
+            return true;
+        }
+        return (typeof value === 'object' &&
+            JSON.stringify(value) ===
+                JSON.stringify(SettingsManagerMandatoryPlaceholderForObject));
+    }
+};
+EnvSettingsManager = EnvSettingsManager_1 = __decorate([
+    injectable(),
+    __param(0, inject('EnvironmentManager')),
+    __param(1, inject('Settings')),
+    __metadata("design:paramtypes", [Object, Object])
+], EnvSettingsManager);
+export { EnvSettingsManager };

package/dist/esm/std/impl/FakeEmailManager.d.ts

@@ -0,0 +1,13 @@
+import type { Email } from '../../dt/index.js';
+import type { EmailManager, EmailManagerEmailDef, EmailManagerEmailDefInputBase } from '../EmailManager.js';
+export declare class FakeEmailManager implements EmailManager {
+    entries: {
+        def: EmailManagerEmailDef<any>;
+        replyTo?: Email | undefined;
+        to: Email[];
+    }[];
+    constructor();
+    clear(): Promise<void>;
+    send<I extends EmailManagerEmailDefInputBase>(def: EmailManagerEmailDef<I>, to: Email[], replyTo?: Email | undefined): Promise<void>;
+    verify(): Promise<void>;
+}

package/dist/esm/std/impl/FakeEmailManager.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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { injectable } from 'inversify';
+let FakeEmailManager = class FakeEmailManager {
+    entries;
+    constructor() {
+        this.entries = [];
+    }
+    async clear() {
+        this.entries = [];
+    }
+    async send(def, to, replyTo) {
+        this.entries.push({ def, replyTo, to });
+    }
+    async verify() {
+    }
+};
+FakeEmailManager = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], FakeEmailManager);
+export { FakeEmailManager };

package/dist/esm/std/impl/FakeFSManager.d.ts

@@ -0,0 +1,23 @@
+import type { DirPath, File, FileExtension, FileName, FilePath, FreeTextLong } from '../../dt/index.js';
+import { type FSManager, type FSManagerCatOpts, type FSManagerChmodMode, type FSManagerItemInfo, type FSManagerLsItem, type FSManagerLsOpts, type Pathname } from '../FSManager.js';
+export declare class FakeFSManager implements FSManager {
+    entries: Map<FilePath, {
+        content: FreeTextLong;
+        mode: FSManagerChmodMode;
+    }>;
+    constructor();
+    canHandleFiles(): Promise<boolean>;
+    cat<T extends string>(path: FilePath, _opts?: FSManagerCatOpts): Promise<T>;
+    chmod(path: Pathname, mode: FSManagerChmodMode): Promise<void>;
+    cp(src: Pathname, dest: Pathname): Promise<void>;
+    echoIn<T extends string>(src: FilePath, content: T): Promise<void>;
+    exists(_path: Pathname): Promise<boolean>;
+    fileExtension(fileName: FileName): FileExtension;
+    info(_path: Pathname): Promise<FSManagerItemInfo>;
+    ls(path: DirPath, _opts?: FSManagerLsOpts): Promise<FSManagerLsItem[]>;
+    mkdir(path: DirPath): Promise<void>;
+    path(...parts: Pathname[]): Pathname;
+    pickFiles(): Promise<File[]>;
+    rm(path: Pathname): Promise<void>;
+    touch<T extends string>(path: FilePath, content: T): Promise<void>;
+}

package/dist/esm/std/impl/FakeFSManager.js

@@ -0,0 +1,104 @@
+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 { injectable } from 'inversify';
+import { FSManagerItemInfoType, } from '../FSManager.js';
+let FakeFSManager = class FakeFSManager {
+    entries;
+    constructor() {
+        this.entries = new Map();
+    }
+    async canHandleFiles() {
+        return true;
+    }
+    async cat(path, _opts) {
+        const value = this.entries.get(path);
+        if (value === undefined) {
+            throw new Error(`Cannot open file at ${path}`);
+        }
+        return value?.content;
+    }
+    async chmod(path, mode) {
+        const value = this.entries.get(path);
+        if (value) {
+            value.mode = mode;
+        }
+    }
+    async cp(src, dest) {
+        this.entries.forEach((value, path) => {
+            if (path.startsWith(src)) {
+                const newPath = path.replace(src, dest);
+                this.entries.set(newPath, value);
+            }
+        });
+    }
+    async echoIn(src, content) {
+        this.entries.set(src, { content, mode: 0o755 });
+    }
+    async exists(_path) {
+        return false;
+    }
+    fileExtension(fileName) {
+        const nameParts = fileName.split('.');
+        const extension = nameParts[nameParts.length - 1]?.toLowerCase();
+        return extension;
+    }
+    async info(_path) {
+        return {
+            base: '',
+            birthtime: '2024-06-03T16:03:00.000Z',
+            dir: '',
+            ext: '',
+            mimeType: 'application/pdf',
+            name: '',
+            root: '',
+            size: 123,
+            type: FSManagerItemInfoType.FILE,
+        };
+    }
+    async ls(path, _opts) {
+        const files = [];
+        this.entries.forEach((_, p) => {
+            if (p.startsWith(path)) {
+                files.push({
+                    path: p,
+                    type: FSManagerItemInfoType.FILE,
+                });
+            }
+        });
+        return files;
+    }
+    async mkdir(path) {
+        this.entries.set(path, { content: '.', mode: 0o755 });
+    }
+    path(...parts) {
+        const resolvedArgs = parts.flatMap((part) => part?.split('/'));
+        while (resolvedArgs.includes('..')) {
+            const index = resolvedArgs.indexOf('..');
+            if (index > 0) {
+                resolvedArgs.splice(index - 1, 2);
+            }
+        }
+        return resolvedArgs.join('/');
+    }
+    async pickFiles() {
+        throw new Error('Method not implemented.');
+    }
+    async rm(path) {
+        this.entries.delete(path);
+    }
+    async touch(path, content) {
+        this.entries.set(path, { content, mode: 0o755 });
+    }
+};
+FakeFSManager = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], FakeFSManager);
+export { FakeFSManager };

package/dist/esm/std/impl/FakeHTTPAPICallExecutor.d.ts

@@ -0,0 +1,9 @@
+import type { HTML, JSONString, URL as URLString } from '../../dt/index.js';
+import type { HTTPAPICallExecutor, HTTPAPICallExecutorFunc } from '../HTTPAPICallExecutor.js';
+import { FetchHTTPAPICallExecutor } from './FetchHTTPAPICallExecutor.js';
+export declare class FakeHTTPAPICallExecutor implements HTTPAPICallExecutor {
+    private fetchHTTPAPICallExecutor;
+    entries: Map<URL | URLString, HTML | JSONString>;
+    constructor(fetchHTTPAPICallExecutor: FetchHTTPAPICallExecutor);
+    fn<Res>(): HTTPAPICallExecutorFunc<Res>;
+}

package/dist/esm/std/impl/FakeHTTPAPICallExecutor.js

@@ -0,0 +1,74 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { FetchHTTPAPICallExecutor } from './FetchHTTPAPICallExecutor.js';
+let FakeHTTPAPICallExecutor = class FakeHTTPAPICallExecutor {
+    fetchHTTPAPICallExecutor;
+    entries;
+    constructor(fetchHTTPAPICallExecutor) {
+        this.fetchHTTPAPICallExecutor = fetchHTTPAPICallExecutor;
+        this.entries = new Map();
+    }
+    fn() {
+        return async (url, info) => {
+            if (url.toString().startsWith('http://localhost')) {
+                return this.fetchHTTPAPICallExecutor.fn()(url, info);
+            }
+            const key = (typeof url === 'string' ? url : url.toString());
+            const content = this.entries.get(key);
+            if (!content) {
+                const message = `Endpoint ${url} not defined in FakeHTTPAPICallExecutor.entries`;
+                return {
+                    arrayBuffer: async () => Buffer.from(''),
+                    body: {
+                        readable: true,
+                    },
+                    headers: {
+                        entries: () => [
+                            ['Content-Type', 'application/json'],
+                        ].values(),
+                        get: (_) => 'application/json',
+                    },
+                    json: async () => ({ message }),
+                    ok: false,
+                    redirected: false,
+                    status: 404,
+                    text: async () => message,
+                };
+            }
+            return {
+                arrayBuffer: async () => Buffer.from(content),
+                body: {
+                    readable: true,
+                },
+                headers: {
+                    entries: () => [
+                        ['Content-Type', 'application/json'],
+                    ].values(),
+                    get: (_) => 'application/json',
+                },
+                json: async () => JSON.parse(content),
+                ok: true,
+                redirected: false,
+                status: 200,
+                text: async () => content,
+            };
+        };
+    }
+};
+FakeHTTPAPICallExecutor = __decorate([
+    injectable(),
+    __param(0, inject(FetchHTTPAPICallExecutor)),
+    __metadata("design:paramtypes", [FetchHTTPAPICallExecutor])
+], FakeHTTPAPICallExecutor);
+export { FakeHTTPAPICallExecutor };

package/dist/esm/std/impl/FakeJobManager.d.ts

@@ -0,0 +1,12 @@
+import type { JobManager, JobManagerJobName, JobManagerQueueName } from '../JobManager.js';
+export declare class FakeJobManager implements JobManager {
+    entries: {
+        input: unknown;
+        jobName: JobManagerJobName;
+        queueName: JobManagerQueueName;
+    }[];
+    constructor();
+    clear(): Promise<void>;
+    dispatch<I>(queueName: JobManagerQueueName, jobName: JobManagerJobName, input: I): Promise<void>;
+    init(): Promise<void>;
+}

package/dist/esm/std/impl/FakeJobManager.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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { injectable } from 'inversify';
+let FakeJobManager = class FakeJobManager {
+    entries;
+    constructor() {
+        this.entries = [];
+    }
+    async clear() {
+        this.entries = [];
+    }
+    async dispatch(queueName, jobName, input) {
+        this.entries.push({ input, jobName, queueName });
+    }
+    async init() {
+    }
+};
+FakeJobManager = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], FakeJobManager);
+export { FakeJobManager };

package/dist/esm/std/impl/FetchHTTPAPICallExecutor.d.ts

@@ -0,0 +1,4 @@
+import type { HTTPAPICallExecutor, HTTPAPICallExecutorFunc } from '../HTTPAPICallExecutor.js';
+export declare class FetchHTTPAPICallExecutor implements HTTPAPICallExecutor {
+    fn<Res>(): HTTPAPICallExecutorFunc<Res>;
+}

package/dist/esm/std/impl/FetchHTTPAPICallExecutor.js

@@ -0,0 +1,16 @@
+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 { injectable } from 'inversify';
+let FetchHTTPAPICallExecutor = class FetchHTTPAPICallExecutor {
+    fn() {
+        return fetch;
+    }
+};
+FetchHTTPAPICallExecutor = __decorate([
+    injectable()
+], FetchHTTPAPICallExecutor);
+export { FetchHTTPAPICallExecutor };

package/dist/esm/std/impl/JoseJWTManager.d.ts

@@ -0,0 +1,14 @@
+import type { JWT } from '../../dt/index.js';
+import type { ClockManager } from '../ClockManager.js';
+import type { JWTManager, JWTManagerDecodeOpts, JWTManagerEncodeOpts, JWTManagerSettings } from '../JWTManager.js';
+import type { SettingsManager } from '../SettingsManager.js';
+export type S = Omit<JWTManagerSettings, 'jwt_manager_invalidate_issued_before'>;
+export declare class JoseJWTManager implements JWTManager {
+    private clockManager;
+    private settingsManager;
+    constructor(clockManager: ClockManager, settingsManager: SettingsManager<S>);
+    s(): S;
+    decode<T extends object>(value: JWT, opts?: JWTManagerDecodeOpts): Promise<T>;
+    encode<T extends object>(payload: T, opts?: JWTManagerEncodeOpts): Promise<JWT>;
+    isUsable(value: JWT): Promise<boolean>;
+}

package/dist/esm/std/impl/JoseJWTManager.js

@@ -0,0 +1,110 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { SignJWT, decodeJwt, decodeProtectedHeader, importPKCS8, importSPKI, jwtVerify, } from 'jose';
+import { JWSSignatureVerificationFailed } from 'jose/errors';
+import { UnauthorizedError } from '../../error/index.js';
+import { assertIsDefined } from '../../utils/index.js';
+let JoseJWTManager = class JoseJWTManager {
+    clockManager;
+    settingsManager;
+    constructor(clockManager, settingsManager) {
+        this.clockManager = clockManager;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            jwt_manager_algorithm: this.settingsManager.get()('jwt_manager_algorithm'),
+            jwt_manager_audience: this.settingsManager.get()('jwt_manager_audience'),
+            jwt_manager_expires_in: this.settingsManager.get()('jwt_manager_expires_in'),
+            jwt_manager_issuer: this.settingsManager.get()('jwt_manager_issuer'),
+            jwt_manager_key_id: this.settingsManager.get()('jwt_manager_key_id'),
+            jwt_manager_secret: this.settingsManager.get()('jwt_manager_secret'),
+            jwt_manager_subject: this.settingsManager.get()('jwt_manager_subject'),
+        };
+    }
+    async decode(value, opts) {
+        const { alg } = decodeProtectedHeader(value);
+        assertIsDefined(alg, 'alg');
+        const secret = opts?.secret || this.s().jwt_manager_secret;
+        try {
+            if (alg.startsWith('HS')) {
+                return (await jwtVerify(value, new TextEncoder().encode(secret))).payload;
+            }
+            if (alg.startsWith('RS')) {
+                assertIsDefined(opts?.spki, 'opts.spki');
+                const publicKey = await importSPKI(opts?.spki, alg);
+                return (await jwtVerify(value, publicKey)).payload;
+            }
+        }
+        catch (err) {
+            if (err instanceof JWSSignatureVerificationFailed) {
+                throw new UnauthorizedError();
+            }
+        }
+        throw new Error(`Unsupported alg ${alg}`);
+    }
+    async encode(payload, opts) {
+        const alg = opts?.alg ?? this.s().jwt_manager_algorithm;
+        const aud = opts?.aud ?? this.s().jwt_manager_audience;
+        const exp = opts?.exp ?? this.s().jwt_manager_expires_in;
+        const iss = opts?.iss ?? this.s().jwt_manager_issuer;
+        const kid = opts?.kid ?? this.s().jwt_manager_key_id;
+        const secret = opts?.secret ?? this.s().jwt_manager_secret;
+        const subject = opts?.sub ?? this.s().jwt_manager_subject;
+        const typ = 'JWT';
+        const header = { alg, typ };
+        if (kid) {
+            header.kid = kid;
+        }
+        const builder = new SignJWT(payload)
+            .setAudience(aud)
+            .setExpirationTime(exp)
+            .setIssuer(iss)
+            .setIssuedAt()
+            .setProtectedHeader(header);
+        if (subject) {
+            builder.setSubject(subject);
+        }
+        if (alg.startsWith('HS')) {
+            return builder.sign(new TextEncoder().encode(secret));
+        }
+        if (alg.startsWith('RS')) {
+            return builder.sign(await importPKCS8(secret, alg));
+        }
+        throw new Error(`Unsupported alg ${alg}`);
+    }
+    async isUsable(value) {
+        const decoded = decodeJwt(value);
+        if (!(decoded &&
+            typeof decoded === 'object' &&
+            'exp' in decoded &&
+            typeof decoded.exp === 'number')) {
+            return false;
+        }
+        const now = this.clockManager.time();
+        const { exp } = decoded;
+        const isExpired = exp < now;
+        if (isExpired) {
+            return false;
+        }
+        return true;
+    }
+};
+JoseJWTManager = __decorate([
+    injectable(),
+    __param(0, inject('ClockManager')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], JoseJWTManager);
+export { JoseJWTManager };

package/dist/esm/std/impl/NodeBufferManager.d.ts

@@ -0,0 +1,9 @@
+import type { BufferManager, BufferManagerBase64String } from '../BufferManager.js';
+export declare class NodeBufferManager implements BufferManager {
+    decodeBase64<T extends string>(value: BufferManagerBase64String): T;
+    decodeUint8Array<T extends string>(value: Uint8Array): T;
+    encodeBase64<T extends string>(value: T): BufferManagerBase64String;
+    encodeUint8Array<T extends string>(value: T): Uint8Array;
+    from<T extends string>(value: T): Buffer;
+    fromHexToBase64<T extends string>(value: T): BufferManagerBase64String;
+}

package/dist/esm/std/impl/NodeBufferManager.js

@@ -0,0 +1,31 @@
+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 { injectable } from 'inversify';
+let NodeBufferManager = class NodeBufferManager {
+    decodeBase64(value) {
+        return Buffer.from(value, 'base64').toString('ascii');
+    }
+    decodeUint8Array(value) {
+        return Buffer.from(value).toString('hex');
+    }
+    encodeBase64(value) {
+        return Buffer.from(value).toString('base64');
+    }
+    encodeUint8Array(value) {
+        return Uint8Array.from(Buffer.from(value, 'hex'));
+    }
+    from(value) {
+        return Buffer.from(value);
+    }
+    fromHexToBase64(value) {
+        return Buffer.from(value, 'hex').toString('base64');
+    }
+};
+NodeBufferManager = __decorate([
+    injectable()
+], NodeBufferManager);
+export { NodeBufferManager };

package/dist/esm/std/impl/NodeCryptoManager.d.ts

@@ -0,0 +1,13 @@
+import type { Password, UIntQuantity, UUID } from '../../dt/index.js';
+import type { BufferManagerBase64String } from '../BufferManager.js';
+import type { CryptoManager, CryptoManagerBinaryToTextEncoding, CryptoManagerHMACKey, CryptoManagerHMACKeyEncoding, CryptoManagerHash, CryptoManagerHashAlgorithm, CryptoManagerRandomString, CryptoManagerSalt, CryptoManagerSaltedScrypt } from '../CryptoManager.js';
+export declare class NodeCryptoManager implements CryptoManager {
+    clear(): Promise<void>;
+    hash(algorithm: CryptoManagerHashAlgorithm, base: string, binaryToTextEncoding: CryptoManagerBinaryToTextEncoding): CryptoManagerHash;
+    hmacToBase64(algorithm: CryptoManagerHashAlgorithm, base: string, key: CryptoManagerHMACKey, keyEncoding: CryptoManagerHMACKeyEncoding): BufferManagerBase64String;
+    hmacToHex(algorithm: CryptoManagerHashAlgorithm, base: string, key: CryptoManagerHMACKey, keyEncoding: CryptoManagerHMACKeyEncoding): CryptoManagerHash;
+    pbkdf2(password: Password, salt: CryptoManagerSalt, iterationsCount: UIntQuantity, keyLength: UIntQuantity, digest: CryptoManagerHashAlgorithm): Promise<Uint8Array>;
+    randomString(length: UIntQuantity): Promise<CryptoManagerRandomString>;
+    randomUUID(): UUID;
+    scrypt(password: Password, salt: CryptoManagerSalt, keyLength: UIntQuantity): Promise<CryptoManagerSaltedScrypt>;
+}