@aopslab/domain-kit-docman 0.1.4

package/dist/errors/friendly.js

@@ -0,0 +1,407 @@
+import { XfInputRequiredError, XfMessageType, XfNotFoundError, XfValidationError, failure, invalid, xfAddMsg, } from '@aopslab/xf-core';
+import { RepositoryError } from '@aopslab/xf-db';
+import * as Cause from 'effect/Cause';
+import { FiberFailureCauseId } from 'effect/Runtime';
+const DOMAIN_SCOPE = 'docman';
+const RUNTIME_SQL_PATTERNS = [
+    /failed query:/i,
+    /\bparams:\s*\[/i,
+    /\binsert into\b/i,
+    /\bupdate\b.+\bset\b/i,
+    /\bdelete from\b/i,
+    /\bselect\b.+\bfrom\b/i,
+    /\bsqlite/i,
+    /\bpostgres/i,
+    /\bdrizzle/i,
+];
+const INPUT_VALIDATION_PATTERNS = [
+    /missing_required_arg:/i,
+    /unknown_input_arg:/i,
+    /tool_input_schema_invalid:/i,
+    /validation/i,
+    /input required/i,
+];
+const NOT_FOUND_PATTERNS = [/record not found/i, /not found/i];
+const UNAUTHORIZED_PATTERNS = [/^unauthorized$/i, /auth required/i, /missing access token/i];
+const FORBIDDEN_PATTERNS = [/^forbidden$/i, /permission denied/i];
+const CONFLICT_PATTERNS = [/duplicate/i, /already exists/i, /conflict/i, /e11000/i];
+const RATE_LIMIT_PATTERNS = [/rate limit/i, /too many requests/i, /too many attempts/i];
+const INVALID_REFERENCE_PATTERNS = [
+    /\bforeign key\b/i,
+    /violates foreign key constraint/i,
+    /is not present in table/i,
+    /anahtarı mevcut değildir/i,
+];
+function normalizeNonEmpty(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeRepositoryErrorCode(value) {
+    const normalized = normalizeNonEmpty(value);
+    switch (normalized) {
+        case 'NotFound':
+        case 'DeleteRecordNotFound':
+        case 'NoRecordReturned':
+        case 'ForeignKeyViolation':
+        case 'UniqueViolation':
+        case 'MultipleRecordsFound':
+        case 'MultipleRecordsReturned':
+        case 'NotNullViolation':
+        case 'CheckViolation':
+            return normalized;
+        default:
+            return undefined;
+    }
+}
+function isRepositoryErrorLike(value) {
+    return Boolean(value) && typeof value === 'object' && (value instanceof RepositoryError || value._tag === 'RepositoryError');
+}
+function extractCandidateSearchText(value) {
+    if (!value)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (value instanceof Error)
+        return value.message;
+    if (typeof value === 'object') {
+        const message = normalizeNonEmpty(value.message);
+        if (message)
+            return message;
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return '';
+        }
+    }
+    return String(value);
+}
+function hasInvalidReferenceSignal(value) {
+    const text = extractCandidateSearchText(value);
+    return text.length > 0 && matches(INVALID_REFERENCE_PATTERNS, text);
+}
+function extractTrace(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const rec = error;
+    const stage = typeof rec.stage === 'string' ? rec.stage : undefined;
+    const operation = typeof rec.operation === 'string' ? rec.operation : undefined;
+    if (!stage && !operation)
+        return undefined;
+    return { stage, operation };
+}
+function unwrapEffectError(error) {
+    if (error && typeof error === 'object') {
+        const rec = error;
+        const key = FiberFailureCauseId;
+        const cause = rec[key];
+        if (cause) {
+            const root = cause;
+            const failureCause = Cause.failureOption(root);
+            if (failureCause._tag === 'Some')
+                return failureCause.value;
+            const defect = Cause.dieOption(root);
+            if (defect._tag === 'Some')
+                return defect.value;
+        }
+    }
+    return error;
+}
+function matches(patterns, value) {
+    return patterns.some((rx) => rx.test(value));
+}
+function buildFriendly(partial) {
+    return {
+        scope: DOMAIN_SCOPE,
+        severity: partial.severity ?? 'user',
+        ...partial,
+    };
+}
+function wrapValidation(error) {
+    let field;
+    if (error instanceof XfInputRequiredError) {
+        const maybeField = error.field;
+        field = typeof maybeField === 'string' ? maybeField : undefined;
+    }
+    return buildFriendly({
+        code: `${DOMAIN_SCOPE}.validation`,
+        status: 400,
+        messages: [{ key: 'error__validation', field, type: 'validation' }],
+        logLevel: 'info',
+        trace: extractTrace(error),
+        cause: error,
+    });
+}
+function wrapNotFound(error) {
+    return buildFriendly({
+        code: `${DOMAIN_SCOPE}.notFound`,
+        status: 404,
+        messages: [{ key: 'error__notFound' }],
+        logLevel: 'info',
+        trace: extractTrace(error),
+        cause: error,
+    });
+}
+function wrapUnauthorized(error) {
+    return buildFriendly({
+        code: `${DOMAIN_SCOPE}.unauthorized`,
+        status: 401,
+        messages: [{ key: 'error__unauthorized' }],
+        logLevel: 'info',
+        trace: extractTrace(error),
+        cause: error,
+    });
+}
+function wrapForbidden(error) {
+    return buildFriendly({
+        code: `${DOMAIN_SCOPE}.forbidden`,
+        status: 403,
+        messages: [{ key: 'error__forbidden' }],
+        logLevel: 'info',
+        trace: extractTrace(error),
+        cause: error,
+    });
+}
+function wrapConflict(error) {
+    return buildFriendly({
+        code: `${DOMAIN_SCOPE}.conflict`,
+        status: 409,
+        messages: [{ key: 'error__conflict' }],
+        logLevel: 'warn',
+        trace: extractTrace(error),
+        cause: error,
+    });
+}
+function wrapRateLimit(error) {
+    return buildFriendly({
+        code: `${DOMAIN_SCOPE}.rateLimit`,
+        status: 429,
+        messages: [{ key: 'error__rateLimit' }],
+        logLevel: 'warn',
+        trace: extractTrace(error),
+        cause: error,
+    });
+}
+function wrapServiceUnavailable(error) {
+    return buildFriendly({
+        code: `${DOMAIN_SCOPE}.serviceUnavailable`,
+        status: 503,
+        messages: [{ key: 'error__serviceUnavailable' }],
+        logLevel: 'error',
+        severity: 'system',
+        trace: extractTrace(error),
+        cause: error,
+    });
+}
+function wrapUnexpected(error) {
+    return buildFriendly({
+        code: `${DOMAIN_SCOPE}.unexpected`,
+        status: 500,
+        messages: [{ key: 'error__unexpected' }],
+        logLevel: 'error',
+        severity: 'system',
+        trace: extractTrace(error),
+        cause: error,
+    });
+}
+export function toFriendlyError(inputError) {
+    const unwrapped = unwrapEffectError(inputError);
+    if (unwrapped instanceof XfValidationError || unwrapped instanceof XfInputRequiredError) {
+        return wrapValidation(unwrapped);
+    }
+    if (unwrapped instanceof XfNotFoundError) {
+        return wrapNotFound(unwrapped);
+    }
+    if (hasInvalidReferenceSignal(unwrapped)) {
+        return wrapNotFound(unwrapped);
+    }
+    if (isRepositoryErrorLike(unwrapped)) {
+        const code = normalizeRepositoryErrorCode(unwrapped.code);
+        if (code === 'NotFound' || code === 'DeleteRecordNotFound' || code === 'NoRecordReturned' || code === 'ForeignKeyViolation') {
+            return wrapNotFound(unwrapped);
+        }
+        if (code === 'UniqueViolation' || code === 'MultipleRecordsFound' || code === 'MultipleRecordsReturned') {
+            return wrapConflict(unwrapped);
+        }
+        if (code === 'NotNullViolation' || code === 'CheckViolation') {
+            return wrapValidation(unwrapped);
+        }
+        const message = normalizeNonEmpty(unwrapped.message) ?? '';
+        if (matches(CONFLICT_PATTERNS, message))
+            return wrapConflict(unwrapped);
+        if (matches(INPUT_VALIDATION_PATTERNS, message))
+            return wrapValidation(unwrapped);
+        return wrapServiceUnavailable(unwrapped);
+    }
+    if (unwrapped instanceof Error) {
+        const message = normalizeNonEmpty(unwrapped.message) ?? '';
+        if (matches(UNAUTHORIZED_PATTERNS, message))
+            return wrapUnauthorized(unwrapped);
+        if (matches(FORBIDDEN_PATTERNS, message))
+            return wrapForbidden(unwrapped);
+        if (matches(NOT_FOUND_PATTERNS, message))
+            return wrapNotFound(unwrapped);
+        if (matches(RATE_LIMIT_PATTERNS, message))
+            return wrapRateLimit(unwrapped);
+        if (matches(CONFLICT_PATTERNS, message))
+            return wrapConflict(unwrapped);
+        if (matches(INPUT_VALIDATION_PATTERNS, message))
+            return wrapValidation(unwrapped);
+        if (matches(RUNTIME_SQL_PATTERNS, message))
+            return wrapServiceUnavailable(unwrapped);
+    }
+    if (typeof unwrapped === 'string') {
+        if (matches(UNAUTHORIZED_PATTERNS, unwrapped))
+            return wrapUnauthorized(unwrapped);
+        if (matches(FORBIDDEN_PATTERNS, unwrapped))
+            return wrapForbidden(unwrapped);
+        if (matches(NOT_FOUND_PATTERNS, unwrapped))
+            return wrapNotFound(unwrapped);
+        if (matches(RATE_LIMIT_PATTERNS, unwrapped))
+            return wrapRateLimit(unwrapped);
+        if (matches(CONFLICT_PATTERNS, unwrapped))
+            return wrapConflict(unwrapped);
+        if (matches(INPUT_VALIDATION_PATTERNS, unwrapped))
+            return wrapValidation(unwrapped);
+        if (matches(RUNTIME_SQL_PATTERNS, unwrapped))
+            return wrapServiceUnavailable(unwrapped);
+    }
+    return wrapUnexpected(unwrapped);
+}
+function toResultMessageOptsGeneric(opts) {
+    const { code, domain, field, params, trace } = opts;
+    return {
+        code,
+        path: field,
+        domain,
+        stage: trace?.stage,
+        operation: trace?.operation,
+        debug: params ? { params } : undefined,
+    };
+}
+function sanitizeCause(cause) {
+    if (cause instanceof Error) {
+        return { name: cause.name, message: cause.message };
+    }
+    if (cause && typeof cause === 'object') {
+        try {
+            JSON.stringify(cause);
+            return cause;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return cause;
+}
+function sanitizeParams(params) {
+    if (!params || typeof params !== 'object')
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (typeof value === 'string')
+            out[key] = value;
+        else if (value != null)
+            out[key] = String(value);
+    }
+    return out;
+}
+function sanitizeMessages(messages) {
+    return messages.map((message) => ({
+        key: String(message.key || ''),
+        field: typeof message.field === 'string' ? message.field : undefined,
+        params: sanitizeParams(message.params),
+        type: message.type === 'validation' ? 'validation' : message.type === 'error' ? 'error' : undefined,
+    }));
+}
+function sanitizeTrace(trace) {
+    if (!trace || typeof trace !== 'object')
+        return undefined;
+    const stage = typeof trace.stage === 'string' ? trace.stage : undefined;
+    const operation = typeof trace.operation === 'string' ? trace.operation : undefined;
+    if (!stage && !operation)
+        return undefined;
+    return { stage, operation };
+}
+function sanitizeFriendly(friendly) {
+    return {
+        ...friendly,
+        messages: sanitizeMessages(Array.isArray(friendly.messages) ? friendly.messages : []),
+        trace: sanitizeTrace(friendly.trace),
+        cause: sanitizeCause(friendly.cause),
+    };
+}
+function appendMessagesGeneric(result, messages, friendly) {
+    return messages.reduce((acc, message) => {
+        return xfAddMsg(acc, message.type === 'validation' ? XfMessageType.ValidationErr : XfMessageType.Error, message.key, toResultMessageOptsGeneric({
+            code: message.key,
+            domain: friendly.scope,
+            field: message.field,
+            params: message.params,
+            trace: friendly.trace,
+        }));
+    }, result);
+}
+export function friendlyErrorToResult(friendly) {
+    const safe = sanitizeFriendly(friendly);
+    const [primary, ...rest] = safe.messages.length ? safe.messages : [{ key: 'error__unexpected' }];
+    const factory = primary.type === 'validation' ? invalid : failure;
+    let result = factory({
+        messageText: primary.key,
+        opts: toResultMessageOptsGeneric({
+            code: primary.key,
+            domain: safe.scope,
+            field: primary.field,
+            params: primary.params,
+            trace: safe.trace,
+        }),
+        error: safe,
+    });
+    if (rest.length > 0) {
+        result = appendMessagesGeneric(result, rest, safe);
+    }
+    return result;
+}
+export function friendlyErrorToResultI18n(friendly, t) {
+    const safe = sanitizeFriendly(friendly);
+    const [primary, ...rest] = safe.messages.length ? safe.messages : [{ key: 'error__unexpected' }];
+    const primaryText = t(primary.key, primary.params);
+    const factory = primary.type === 'validation' ? invalid : failure;
+    let result = factory({
+        messageText: primaryText,
+        opts: toResultMessageOptsGeneric({
+            code: primary.key,
+            domain: safe.scope,
+            field: primary.field,
+            params: primary.params,
+            trace: safe.trace,
+        }),
+        error: safe,
+    });
+    if (rest.length > 0) {
+        result = rest.reduce((acc, message) => {
+            return xfAddMsg(acc, message.type === 'validation' ? XfMessageType.ValidationErr : XfMessageType.Error, t(message.key, message.params), toResultMessageOptsGeneric({
+                code: message.key,
+                domain: safe.scope,
+                field: message.field,
+                params: message.params,
+                trace: safe.trace,
+            }));
+        }, result);
+    }
+    return result;
+}
+export function friendlyErrorToHttpBody(friendly) {
+    const safe = sanitizeFriendly(friendly);
+    return {
+        ok: false,
+        code: safe.code,
+        severity: safe.severity,
+        messages: safe.messages,
+    };
+}
+export function errorToResult(error) {
+    return friendlyErrorToResult(toFriendlyError(error));
+}

package/dist/errors/i18n.d.ts

@@ -0,0 +1,4 @@
+import type { I18nBm } from '@aopslab/xf-i18n/bm';
+import { type XfFriendlyError } from './friendly.js';
+export declare function friendlyErrorToResultWithI18n<TData = unknown, TField extends object = object, TTag extends object = object, TValidation extends object = object>(friendly: XfFriendlyError, i18nBm: I18nBm<TField, TTag, TValidation>, locale?: string): import("@aopslab/xf-core").XfResult<TData, XfFriendlyError>;
+export declare function errorToResultWithI18n<TData = unknown, TField extends object = object, TTag extends object = object, TValidation extends object = object>(error: unknown, i18nBm: I18nBm<TField, TTag, TValidation>, locale?: string): import("@aopslab/xf-core").XfResult<TData, XfFriendlyError>;

package/dist/errors/i18n.js

@@ -0,0 +1,10 @@
+import { friendlyErrorToResultI18n, toFriendlyError, } from './friendly.js';
+export function friendlyErrorToResultWithI18n(friendly, i18nBm, locale) {
+    const t = i18nBm.getTagTranslator({ locale });
+    return friendlyErrorToResultI18n(friendly, t);
+}
+export function errorToResultWithI18n(error, i18nBm, locale) {
+    const t = i18nBm.getTagTranslator({ locale });
+    const friendly = toFriendlyError(error);
+    return friendlyErrorToResultI18n(friendly, t);
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './friendly.js';
+export * from './error.map.js';
+export * from './i18n.js';

package/dist/errors/index.js

@@ -0,0 +1,3 @@
+export * from './friendly.js';
+export * from './error.map.js';
+export * from './i18n.js';

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './domain-services/types.js';
+export { createDocmanKit, createDocmanKitWithEnv, buildDocmanKitStaticConfig } from './domain-services/unified.js';
+export * from './config/config.js';
+export * from './operations/index.js';
+export type * from '@aopslab/domain-dm-docman/models';
+export type * from '@aopslab/domain-dm-docman/ports';
+export * from './errors/index.js';
+export * from './resources/index.js';
+export * from './shared/index.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from './domain-services/types.js';
+export { createDocmanKit, createDocmanKitWithEnv, buildDocmanKitStaticConfig } from './domain-services/unified.js';
+export * from './config/config.js';
+export * from './operations/index.js';
+export * from './errors/index.js';
+export * from './resources/index.js';
+export * from './shared/index.js';

package/dist/operations/catalog.d.ts

@@ -0,0 +1,11 @@
+import type { DocmanOperationSpec } from './types.js';
+export declare function listDocmanOperationSpecs(options?: {
+    refresh?: boolean;
+}): DocmanOperationSpec[];
+export declare function getDocmanOperationByToolId(toolId: string, options?: {
+    refresh?: boolean;
+}): DocmanOperationSpec | null;
+export declare function getDocmanOperationById(operationId: string, options?: {
+    refresh?: boolean;
+}): DocmanOperationSpec | null;
+export { buildDocmanToolIdFromOperation } from './definition.js';