@zintrust/core 2.4.1 → 2.4.3

package/src/tools/redis/RedisTransport.js

@@ -0,0 +1,359 @@
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { parseCustomHeadersFromEnv } from '../../orm/adapters/SqlProxyAdapterUtils.js';
+import { SignedRequest } from '../../security/SignedRequest.js';
+const loggedSelections = new Set();
+const readEnvString = (key, fallback = '') => {
+    if (typeof Env.get === 'function') {
+        return Env.get(key, fallback);
+    }
+    const value = Env[key];
+    return typeof value === 'string' ? value : fallback;
+};
+const readEnvBool = (key, fallback = false) => {
+    if (typeof Env.getBool === 'function') {
+        return Env.getBool(key, fallback);
+    }
+    const value = Env[key];
+    return typeof value === 'boolean' ? value : fallback;
+};
+const readEnvInt = (key, fallback) => {
+    if (typeof Env.getInt === 'function') {
+        return Env.getInt(key, fallback);
+    }
+    const value = Env[key];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isNaN(parsed) ? fallback : parsed;
+    }
+    return fallback;
+};
+const resolveSigningPrefix = (baseUrl) => {
+    try {
+        const parsed = new URL(baseUrl);
+        const path = parsed.pathname.endsWith('/') ? parsed.pathname.slice(0, -1) : parsed.pathname;
+        if (path === '' || path === '/')
+            return undefined;
+        return path;
+    }
+    catch {
+        return undefined;
+    }
+};
+const buildRequestUrl = (baseUrl, requestPath) => {
+    const url = new URL(baseUrl);
+    const basePath = url.pathname.endsWith('/') ? url.pathname.slice(0, -1) : url.pathname;
+    const normalizedPath = requestPath.startsWith('/') ? requestPath : `/${requestPath}`;
+    url.pathname = `${basePath}${normalizedPath}`;
+    return url;
+};
+const buildSigningUrl = (requestUrl, baseUrl) => {
+    const prefix = resolveSigningPrefix(baseUrl);
+    if (prefix === undefined)
+        return requestUrl;
+    if (requestUrl.pathname === prefix || requestUrl.pathname.startsWith(`${prefix}/`)) {
+        const signingUrl = new URL(requestUrl.toString());
+        const stripped = requestUrl.pathname.slice(prefix.length);
+        signingUrl.pathname = stripped.startsWith('/') ? stripped : `/${stripped}`;
+        return signingUrl;
+    }
+    return requestUrl;
+};
+const resolveProxyBaseUrl = () => {
+    const explicit = readEnvString('REDIS_PROXY_URL', '').trim();
+    if (explicit !== '')
+        return explicit;
+    return `http://${Env.REDIS_PROXY_HOST}:${Env.REDIS_PROXY_PORT}`;
+};
+const resolveProxySettings = () => ({
+    baseUrl: resolveProxyBaseUrl(),
+    keyId: Env.REDIS_PROXY_KEY_ID.trim() === '' ? undefined : Env.REDIS_PROXY_KEY_ID,
+    secret: Env.REDIS_PROXY_SECRET.trim() === '' ? undefined : Env.REDIS_PROXY_SECRET,
+    timeoutMs: Env.REDIS_PROXY_TIMEOUT_MS,
+    customHeaders: parseCustomHeadersFromEnv('REDIS'),
+});
+const isRedisRpcEnabled = () => readEnvBool('USE_REDIS_PROXY', false) && readEnvString('REDIS_RPC_URL', '').trim() !== '';
+const resolveRpcSettings = () => ({
+    baseUrl: readEnvString('REDIS_RPC_URL', '').trim(),
+    secret: readEnvString('REDIS_RPC_SECRET', readEnvString('REDIS_PROXY_SECRET', readEnvString('APP_KEY', ''))),
+    timeoutMs: readEnvInt('REDIS_RPC_TIMEOUT_MS', 30000),
+});
+const buildHeaders = async (settings, requestUrl, body) => {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (settings.keyId !== undefined && settings.secret !== undefined) {
+        const signingUrl = buildSigningUrl(requestUrl, settings.baseUrl);
+        const signed = await SignedRequest.createHeaders({
+            method: 'POST',
+            url: signingUrl,
+            body,
+            keyId: settings.keyId,
+            secret: settings.secret,
+        });
+        Object.assign(headers, signed);
+    }
+    if (settings.customHeaders !== undefined) {
+        Object.assign(headers, settings.customHeaders);
+    }
+    return headers;
+};
+const requestProxyCommand = async (settings, command, args) => {
+    if (settings.baseUrl.trim() === '') {
+        throw ErrorFactory.createConfigError('Redis proxy URL is missing (REDIS_PROXY_URL)');
+    }
+    const body = JSON.stringify({ command, args });
+    const requestUrl = buildRequestUrl(settings.baseUrl, '/zin/redis/command');
+    const headers = await buildHeaders(settings, requestUrl, body);
+    const signal = typeof AbortSignal !== 'undefined' && 'timeout' in AbortSignal
+        ? AbortSignal.timeout(settings.timeoutMs)
+        : undefined;
+    const response = await fetch(requestUrl.toString(), {
+        method: 'POST',
+        headers,
+        body,
+        signal,
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw ErrorFactory.createTryCatchError(`Redis proxy request failed (${response.status})`, text);
+    }
+    const parsed = (await response.json());
+    return parsed.result;
+};
+const requestRpcMethod = async (settings, method, payload) => {
+    if (settings.baseUrl.trim() === '') {
+        throw ErrorFactory.createConfigError('Redis RPC URL is missing. Set USE_REDIS_PROXY=true and REDIS_RPC_URL.');
+    }
+    const url = new URL('/rpc', settings.baseUrl);
+    const body = JSON.stringify({
+        service: 'redis',
+        method,
+        payload,
+    });
+    const signal = typeof AbortSignal !== 'undefined' && 'timeout' in AbortSignal
+        ? AbortSignal.timeout(settings.timeoutMs)
+        : undefined;
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(settings.secret !== undefined && settings.secret.trim() !== ''
+                ? { 'x-redis-rpc-secret': settings.secret }
+                : {}),
+        },
+        body,
+        signal,
+    });
+    const parsed = (await response.json());
+    if (!response.ok || parsed.ok !== true) {
+        const errorMessage = parsed.error?.message;
+        throw ErrorFactory.createTryCatchError(typeof errorMessage === 'string' && errorMessage.trim() !== ''
+            ? errorMessage
+            : `Redis RPC request failed (${response.status})`, parsed.error?.details);
+    }
+    return parsed.result;
+};
+const requestRpcCommand = async (settings, command, args) => requestRpcMethod(settings, 'call', { args: [command, ...args] });
+const requestRpcPipeline = async (settings, commands, transaction) => {
+    const results = await requestRpcMethod(settings, transaction ? 'multi' : 'pipeline', { commands, transaction });
+    return results.map(([error, result]) => [
+        error === null ? null : ErrorFactory.createTryCatchError(error),
+        result,
+    ]);
+};
+const requestRedisCommand = async (mode, settings, command, args) => {
+    return mode === 'rpc'
+        ? requestRpcCommand(settings, command, args)
+        : requestProxyCommand(settings, command, args);
+};
+const logTransportSelection = (mode, config, options) => {
+    const rawSubsystem = options?.subsystem?.trim();
+    const subsystem = rawSubsystem === undefined || rawSubsystem === '' ? 'redis' : rawSubsystem;
+    const cacheKey = `${subsystem}:${mode}:${config.db}`;
+    if (loggedSelections.has(cacheKey)) {
+        return;
+    }
+    loggedSelections.add(cacheKey);
+    Logger.info('[redis][transport] resolved transport', {
+        subsystem,
+        mode,
+        db: config.db,
+        host: mode === 'direct' ? config.host : undefined,
+        port: mode === 'direct' ? config.port : undefined,
+        proxyUrl: mode === 'proxy' ? resolveProxyBaseUrl() : undefined,
+        rpcUrl: mode === 'rpc' ? readEnvString('REDIS_RPC_URL', '') : undefined,
+    });
+};
+const normalizeScanResponse = (value) => {
+    if (!Array.isArray(value) || value.length < 2) {
+        return ['0', []];
+    }
+    const cursor = typeof value[0] === 'string' ? value[0] : String(value[0] ?? '0');
+    const batch = Array.isArray(value[1])
+        ? value[1].filter((entry) => typeof entry === 'string')
+        : [];
+    return [cursor, batch];
+};
+const createScanStream = (settings, mode, options) => {
+    const handlers = new Map();
+    const stream = {
+        on(event, handler) {
+            const current = handlers.get(event) ?? new Set();
+            current.add(handler);
+            handlers.set(event, current);
+            return stream;
+        },
+        once(event, handler) {
+            const wrapped = (...args) => {
+                stream.off(event, wrapped);
+                handler(...args);
+            };
+            return stream.on(event, wrapped);
+        },
+        off(event, handler) {
+            handlers.get(event)?.delete(handler);
+            return stream;
+        },
+    };
+    const emit = (event, ...args) => {
+        for (const handler of handlers.get(event) ?? []) {
+            handler(...args);
+        }
+    };
+    queueMicrotask(() => {
+        void (async () => {
+            try {
+                let cursor = '0';
+                do {
+                    // eslint-disable-next-line no-await-in-loop
+                    const result = await requestRedisCommand(mode, settings, 'SCAN', [
+                        cursor,
+                        'MATCH',
+                        options?.match ?? '*',
+                        'COUNT',
+                        String(options?.count ?? 200),
+                    ]);
+                    const [nextCursor, batch] = normalizeScanResponse(result);
+                    cursor = nextCursor;
+                    if (batch.length > 0) {
+                        emit('data', batch);
+                    }
+                } while (cursor !== '0');
+                emit('end');
+            }
+            catch (error) {
+                emit('error', error);
+            }
+        })();
+    });
+    return stream;
+};
+const createPipeline = (settings, mode, transaction = false) => {
+    const commands = [];
+    const target = {
+        async exec() {
+            if (mode === 'rpc') {
+                return requestRpcPipeline(settings, commands, transaction);
+            }
+            const results = [];
+            for (const entry of commands) {
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    const result = await requestRedisCommand(mode, settings, entry.command, entry.args);
+                    results.push([null, result]);
+                }
+                catch (error) {
+                    results.push([
+                        error instanceof Error
+                            ? error
+                            : ErrorFactory.createTryCatchError('Redis pipeline command failed', error),
+                        null,
+                    ]);
+                }
+            }
+            return results;
+        },
+    };
+    const pipeline = new Proxy(target, {
+        get(obj, prop) {
+            if (typeof prop !== 'string')
+                return Reflect.get(obj, prop);
+            if (prop in obj)
+                return Reflect.get(obj, prop);
+            return (...args) => {
+                commands.push({ command: prop.toUpperCase(), args });
+                return pipeline;
+            };
+        },
+    });
+    return pipeline;
+};
+export const resolveRedisTransportMode = () => {
+    if (isRedisRpcEnabled())
+        return 'rpc';
+    return readEnvBool('USE_REDIS_PROXY', false) ? 'proxy' : 'direct';
+};
+export const createRedisProxyConnection = (config, options) => {
+    const mode = resolveRedisTransportMode();
+    const settings = mode === 'rpc' ? resolveRpcSettings() : resolveProxySettings();
+    if (mode === 'direct') {
+        throw ErrorFactory.createConfigError('Redis proxy connection requested while direct mode is active.');
+    }
+    logTransportSelection(mode, config, options);
+    const target = {
+        status: 'ready',
+        connect: async () => { },
+        // eslint-disable-next-line @typescript-eslint/require-await
+        quit: async () => 'OK',
+        disconnect: () => undefined,
+        on: (_event, _handler) => client,
+        once: (_event, _handler) => client,
+        off: (_event, _handler) => client,
+        removeListener: (_event, _handler) => client,
+        setMaxListeners: (_count) => client,
+        getMaxListeners: () => Infinity,
+        call: async (command, ...args) => {
+            return requestRedisCommand(mode, settings, command, args);
+        },
+        pipeline: () => createPipeline(settings, mode),
+        multi: () => createPipeline(settings, mode, true),
+        scanStream: (scanOptions) => createScanStream(settings, mode, scanOptions),
+    };
+    const client = new Proxy(target, {
+        get(obj, prop) {
+            if (typeof prop !== 'string')
+                return Reflect.get(obj, prop);
+            if (prop === 'then')
+                return undefined;
+            if (prop === 'setMaxListeners') {
+                return function (_count) {
+                    return client;
+                };
+            }
+            if (prop === 'getMaxListeners') {
+                return function () {
+                    return Infinity;
+                };
+            }
+            if (prop in obj)
+                return Reflect.get(obj, prop);
+            return async (...args) => requestRedisCommand(mode, settings, prop.toUpperCase(), args);
+        },
+    });
+    return client;
+};
+export const ensureRedisTransportMode = (config, options) => {
+    const mode = resolveRedisTransportMode();
+    if (mode === 'proxy' && options?.requireDirect === true) {
+        throw ErrorFactory.createConfigError(`Redis subsystem '${options.subsystem ?? 'redis'}' requires a direct Redis connection, but proxy mode is enabled.`);
+    }
+    if (mode === 'direct') {
+        logTransportSelection(mode, config, options);
+    }
+    return mode;
+};

package/src/tools/storage/LocalSignedUrl.d.ts

@@ -0,0 +1,12 @@
+export type LocalSignedUrlPayload = {
+    disk: 'local';
+    key: string;
+    exp: number;
+    method: 'GET';
+};
+export declare const LocalSignedUrl: Readonly<{
+    createToken(payload: LocalSignedUrlPayload, secret: string): string;
+    verifyToken(token: string, secret: string, nowMs?: number): LocalSignedUrlPayload;
+}>;
+export default LocalSignedUrl;
+//# sourceMappingURL=LocalSignedUrl.d.ts.map

package/src/tools/storage/LocalSignedUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalSignedUrl.d.ts","sourceRoot":"","sources":["../../../../src/tools/storage/LocalSignedUrl.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,KAAK,CAAC;CACf,CAAC;AA8DF,eAAO,MAAM,cAAc;yBACJ,qBAAqB,UAAU,MAAM,GAAG,MAAM;uBAyBhD,MAAM,UAAU,MAAM,UAAS,MAAM,GAAgB,qBAAqB;EA2C7F,CAAC;AAEH,eAAe,cAAc,CAAC"}

package/src/tools/storage/LocalSignedUrl.js

@@ -0,0 +1,108 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { createHmac } from '../../node-singletons/crypto.js';
+const base64UrlEncode = (value) => {
+    const base64 = Buffer.isBuffer(value)
+        ? value.toString('base64')
+        : Buffer.from(value).toString('base64');
+    // replace characters used in regular base64 and remove any trailing '=' padding
+    let result = base64.replaceAll('+', '-').replaceAll('/', '_');
+    // Remove trailing '=' characters without using a regex to avoid potential super-linear backtracking.
+    while (result.endsWith('=')) {
+        result = result.slice(0, -1);
+    }
+    return result;
+};
+const base64UrlDecodeToString = (value) => {
+    const padded = value + '==='.slice((value.length + 3) % 4);
+    const base64 = padded.replaceAll('-', '+').replaceAll('_', '/');
+    return Buffer.from(base64, 'base64').toString('utf8');
+};
+const timingSafeEquals = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result |= (a.codePointAt(i) ?? 0) ^ (b.codePointAt(i) ?? 0);
+    }
+    return result === 0;
+};
+const assertValidKey = (key) => {
+    if (key.trim() === '') {
+        throw ErrorFactory.createValidationError('Local signed url: key is required');
+    }
+    // Hard fail on obvious traversal / absolute paths.
+    // Keep this strict; keys should be relative like `uploads/a.png`.
+    if (key.startsWith('/') || key.startsWith('\\')) {
+        throw ErrorFactory.createValidationError('Local signed url: key must be relative');
+    }
+    const segments = key.split(/[/\\]+/g);
+    if (segments.some((s) => s === '..' || s === '.')) {
+        throw ErrorFactory.createValidationError('Local signed url: invalid key');
+    }
+    if (key.includes('\0')) {
+        throw ErrorFactory.createValidationError('Local signed url: invalid key');
+    }
+};
+const sign = (payloadEncoded, secret) => {
+    if (secret.trim() === '') {
+        throw ErrorFactory.createConfigError('Local signed url: signing secret not configured (set APP_KEY)');
+    }
+    const signature = createHmac('sha256', secret).update(payloadEncoded).digest();
+    return base64UrlEncode(signature);
+};
+export const LocalSignedUrl = Object.freeze({
+    createToken(payload, secret) {
+        assertValidKey(payload.key);
+        if (payload.disk !== 'local') {
+            throw ErrorFactory.createValidationError('Local signed url: unsupported disk', {
+                disk: payload.disk,
+            });
+        }
+        if (payload.method !== 'GET') {
+            throw ErrorFactory.createValidationError('Local signed url: unsupported method', {
+                method: payload.method,
+            });
+        }
+        if (!Number.isFinite(payload.exp) || payload.exp <= 0) {
+            throw ErrorFactory.createValidationError('Local signed url: invalid expiration');
+        }
+        const payloadEncoded = base64UrlEncode(JSON.stringify(payload));
+        const signatureEncoded = sign(payloadEncoded, secret);
+        return `${payloadEncoded}.${signatureEncoded}`;
+    },
+    verifyToken(token, secret, nowMs = Date.now()) {
+        if (token.trim() === '') {
+            throw ErrorFactory.createValidationError('Local signed url: token is required');
+        }
+        const parts = token.split('.');
+        if (parts.length !== 2) {
+            throw ErrorFactory.createValidationError('Local signed url: malformed token');
+        }
+        const payloadEncoded = parts[0] ?? '';
+        const signatureEncoded = parts[1] ?? '';
+        const expectedSignature = sign(payloadEncoded, secret);
+        if (!timingSafeEquals(signatureEncoded, expectedSignature)) {
+            throw ErrorFactory.createSecurityError('Local signed url: invalid signature');
+        }
+        let payload;
+        try {
+            payload = JSON.parse(base64UrlDecodeToString(payloadEncoded));
+        }
+        catch (err) {
+            throw ErrorFactory.createValidationError('Local signed url: invalid payload', { error: err });
+        }
+        const p = payload;
+        if (p.disk !== 'local' ||
+            typeof p.key !== 'string' ||
+            typeof p.exp !== 'number' ||
+            p.method !== 'GET') {
+            throw ErrorFactory.createValidationError('Local signed url: invalid payload');
+        }
+        assertValidKey(p.key);
+        if (p.exp < nowMs) {
+            throw ErrorFactory.createSecurityError('Local signed url: token expired');
+        }
+        return p;
+    },
+});
+export default LocalSignedUrl;

package/src/tools/storage/StorageDiskRegistry.d.ts

@@ -0,0 +1,14 @@
+declare function register(name: string, config: unknown): void;
+declare function has(name: string): boolean;
+declare function get(name: string): unknown;
+declare function list(): string[];
+declare function reset(): void;
+export declare const StorageDiskRegistry: Readonly<{
+    register: typeof register;
+    has: typeof has;
+    get: typeof get;
+    list: typeof list;
+    reset: typeof reset;
+}>;
+export default StorageDiskRegistry;
+//# sourceMappingURL=StorageDiskRegistry.d.ts.map

package/src/tools/storage/StorageDiskRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageDiskRegistry.d.ts","sourceRoot":"","sources":["../../../../src/tools/storage/StorageDiskRegistry.ts"],"names":[],"mappings":"AASA,iBAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAIrD;AAED,iBAAS,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElC;AAED,iBAAS,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOlC;AAED,iBAAS,IAAI,IAAI,MAAM,EAAE,CAExB;AAED,iBAAS,KAAK,IAAI,IAAI,CAErB;AAED,eAAO,MAAM,mBAAmB;;;;;;EAM9B,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/src/tools/storage/StorageDiskRegistry.js

@@ -0,0 +1,36 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const registry = new Map();
+const normalizeKey = (name) => String(name ?? '')
+    .trim()
+    .toLowerCase();
+function register(name, config) {
+    const key = normalizeKey(name);
+    if (key === '')
+        return;
+    registry.set(key, config);
+}
+function has(name) {
+    return registry.has(normalizeKey(name));
+}
+function get(name) {
+    const key = normalizeKey(name);
+    const cfg = registry.get(key);
+    if (cfg === undefined) {
+        throw ErrorFactory.createConfigError(`Storage disk not registered: ${name}`);
+    }
+    return cfg;
+}
+function list() {
+    return Array.from(registry.keys()).sort((a, b) => a.localeCompare(b));
+}
+function reset() {
+    registry.clear();
+}
+export const StorageDiskRegistry = Object.freeze({
+    register,
+    has,
+    get,
+    list,
+    reset,
+});
+export default StorageDiskRegistry;

package/src/tools/storage/StorageDriverRegistry.d.ts

@@ -0,0 +1,18 @@
+export type StorageDriverEntry = {
+    driver: unknown;
+    normalize?: (raw: Record<string, unknown>) => Record<string, unknown>;
+};
+declare function register(driverName: string, entry: StorageDriverEntry): void;
+declare function get(driverName: string): StorageDriverEntry | undefined;
+declare function has(driverName: string): boolean;
+declare function list(): string[];
+declare function clear(): void;
+export declare const StorageDriverRegistry: Readonly<{
+    register: typeof register;
+    get: typeof get;
+    has: typeof has;
+    list: typeof list;
+    clear: typeof clear;
+}>;
+export default StorageDriverRegistry;
+//# sourceMappingURL=StorageDriverRegistry.d.ts.map

package/src/tools/storage/StorageDriverRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageDriverRegistry.d.ts","sourceRoot":"","sources":["../../../../src/tools/storage/StorageDriverRegistry.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvE,CAAC;AAIF,iBAAS,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAErE;AAED,iBAAS,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAE/D;AAED,iBAAS,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAExC;AAED,iBAAS,IAAI,IAAI,MAAM,EAAE,CAExB;AAED,iBAAS,KAAK,IAAI,IAAI,CAErB;AAED,eAAO,MAAM,qBAAqB;;;;;;EAMhC,CAAC;AAEH,eAAe,qBAAqB,CAAC"}

package/src/tools/storage/StorageDriverRegistry.js

@@ -0,0 +1,24 @@
+const registry = new Map();
+function register(driverName, entry) {
+    registry.set(String(driverName).trim().toLowerCase(), entry);
+}
+function get(driverName) {
+    return registry.get(String(driverName).trim().toLowerCase());
+}
+function has(driverName) {
+    return registry.has(String(driverName).trim().toLowerCase());
+}
+function list() {
+    return Array.from(registry.keys()).sort((a, b) => a.localeCompare(b));
+}
+function clear() {
+    registry.clear();
+}
+export const StorageDriverRegistry = Object.freeze({
+    register,
+    get,
+    has,
+    list,
+    clear,
+});
+export default StorageDriverRegistry;

package/src/tools/storage/StorageRuntimeRegistration.d.ts

@@ -0,0 +1,10 @@
+import type { StorageConfigRuntime, StorageDriverConfig } from '../../config/type';
+export type StorageRuntimeConfig = StorageConfigRuntime & {
+    getDriverConfig?: (name?: string) => StorageDriverConfig;
+};
+export declare function registerDisksFromRuntimeConfig(config: StorageRuntimeConfig): void;
+export declare const StorageRuntimeRegistration: Readonly<{
+    registerDisksFromRuntimeConfig: typeof registerDisksFromRuntimeConfig;
+}>;
+export default StorageRuntimeRegistration;
+//# sourceMappingURL=StorageRuntimeRegistration.d.ts.map

package/src/tools/storage/StorageRuntimeRegistration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageRuntimeRegistration.d.ts","sourceRoot":"","sources":["../../../../src/tools/storage/StorageRuntimeRegistration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAI9E,MAAM,MAAM,oBAAoB,GAAG,oBAAoB,GAAG;IACxD,eAAe,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,mBAAmB,CAAC;CAC1D,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAiBjF;AAED,eAAO,MAAM,0BAA0B;;EAErC,CAAC;AAEH,eAAe,0BAA0B,CAAC"}

package/src/tools/storage/StorageRuntimeRegistration.js

@@ -0,0 +1,21 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { StorageDiskRegistry } from './StorageDiskRegistry.js';
+export function registerDisksFromRuntimeConfig(config) {
+    for (const [name, driverConfig] of Object.entries(config.drivers)) {
+        StorageDiskRegistry.register(name, driverConfig);
+    }
+    // Alias reserved name `default` to the configured default.
+    const defaultName = String(config.default ?? '').trim();
+    if (defaultName.length === 0) {
+        throw ErrorFactory.createConfigError('Storage default disk is not configured');
+    }
+    const resolvedDefault = config.drivers[defaultName];
+    if (resolvedDefault === undefined) {
+        throw ErrorFactory.createConfigError(`Storage default disk not configured: ${defaultName}`);
+    }
+    StorageDiskRegistry.register('default', resolvedDefault);
+}
+export const StorageRuntimeRegistration = Object.freeze({
+    registerDisksFromRuntimeConfig,
+});
+export default StorageRuntimeRegistration;

package/src/tools/storage/drivers/Gcs.d.ts

@@ -0,0 +1,20 @@
+export type GcsConfig = {
+    bucket: string;
+    projectId?: string;
+    keyFile?: string;
+    url?: string;
+};
+type TempUrlOptions = {
+    expiresIn?: number;
+    method?: 'GET' | 'PUT';
+};
+export declare const GcsDriver: Readonly<{
+    url(config: GcsConfig, key: string): string | undefined;
+    put(config: GcsConfig, key: string, content: string | Buffer): Promise<string>;
+    get(config: GcsConfig, key: string): Promise<Buffer>;
+    exists(config: GcsConfig, key: string): Promise<boolean>;
+    delete(config: GcsConfig, key: string): Promise<void>;
+    tempUrl(config: GcsConfig, key: string, options?: TempUrlOptions): Promise<string>;
+}>;
+export default GcsDriver;
+//# sourceMappingURL=Gcs.d.ts.map

package/src/tools/storage/drivers/Gcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gcs.d.ts","sourceRoot":"","sources":["../../../../../src/tools/storage/drivers/Gcs.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,KAAK,cAAc,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;CAAE,CAAC;AA+ErE,eAAO,MAAM,SAAS;gBACR,SAAS,OAAO,MAAM,GAAG,MAAM,GAAG,SAAS;gBAWrC,SAAS,OAAO,MAAM,WAAW,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;gBAkBlE,SAAS,OAAO,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;mBAiBrC,SAAS,OAAO,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;mBAgBzC,SAAS,OAAO,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;oBAiBrC,SAAS,OAAO,MAAM,YAAY,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;EA8BxF,CAAC;AAEH,eAAe,SAAS,CAAC"}