@aopslab/domain-kit-docman 0.1.4

package/dist/domain-services/unified.js

@@ -0,0 +1,210 @@
+import { Effect } from 'effect';
+import { cacheKeyFromLocale, CountersMetricsCollector, LoggerMetricsCollector, MultiMetricsCollector, parseEnvConfig, } from '@aopslab/xf-dm-kits';
+import { createDocmanKitProvider } from './provider.js';
+function inferRepositoryType(url) {
+    const normalized = url.trim().toLowerCase();
+    if (!normalized)
+        return 'mongo';
+    if (normalized.startsWith('postgres://') || normalized.startsWith('postgresql://'))
+        return 'drizzle';
+    if (normalized === ':memory:')
+        return 'drizzle';
+    if (normalized.startsWith('sqlite:') || normalized.startsWith('file:'))
+        return 'drizzle';
+    if (normalized.endsWith('.db') || normalized.endsWith('.sqlite') || normalized.endsWith('.sqlite3'))
+        return 'drizzle';
+    return 'mongo';
+}
+export function createDocmanKit(options) {
+    const provider = createDocmanKitProvider({
+        ...options,
+        getCacheKey: options.getCacheKey ?? ((ctx) => cacheKeyFromLocale(ctx.locale, ctx.fallbackLocale)),
+    });
+    return {
+        getStaticConfig() {
+            return options.staticConfig;
+        },
+        getDocumentService: provider.getDocumentService,
+        createDocumentService: provider.createDocumentService,
+        getDocumentGroupService: provider.getDocumentGroupService,
+        createDocumentGroupService: provider.createDocumentGroupService,
+        getDocumentVersionService: provider.getDocumentVersionService,
+        createDocumentVersionService: provider.createDocumentVersionService,
+        getSectionService: provider.getSectionService,
+        createSectionService: provider.createSectionService,
+        getPageService: provider.getPageService,
+        createPageService: provider.createPageService,
+        getPageVersionService: provider.getPageVersionService,
+        createPageVersionService: provider.createPageVersionService,
+        getDocumentSectionLinkService: provider.getDocumentSectionLinkService,
+        createDocumentSectionLinkService: provider.createDocumentSectionLinkService,
+        getSectionPageLinkService: provider.getSectionPageLinkService,
+        createSectionPageLinkService: provider.createSectionPageLinkService,
+        getSnippetService: provider.getSnippetService,
+        createSnippetService: provider.createSnippetService,
+        getPageSnippetLinkService: provider.getPageSnippetLinkService,
+        createPageSnippetLinkService: provider.createPageSnippetLinkService,
+        getAssetService: provider.getAssetService,
+        createAssetService: provider.createAssetService,
+        getAssetVersionService: provider.getAssetVersionService,
+        createAssetVersionService: provider.createAssetVersionService,
+        getEmbedService: provider.getEmbedService,
+        createEmbedService: provider.createEmbedService,
+        getPageEmbedLinkService: provider.getPageEmbedLinkService,
+        createPageEmbedLinkService: provider.createPageEmbedLinkService,
+        getDocumentRepository: provider.getDocumentRepository,
+        getDocumentGroupRepository: provider.getDocumentGroupRepository,
+        getDocumentVersionRepository: provider.getDocumentVersionRepository,
+        getSectionRepository: provider.getSectionRepository,
+        getPageRepository: provider.getPageRepository,
+        getPageVersionRepository: provider.getPageVersionRepository,
+        getDocumentIndexEntryRepository: provider.getDocumentIndexEntryRepository,
+        getDocumentSectionLinkRepository: provider.getDocumentSectionLinkRepository,
+        getSectionPageLinkRepository: provider.getSectionPageLinkRepository,
+        getSnippetRepository: provider.getSnippetRepository,
+        getPageSnippetLinkRepository: provider.getPageSnippetLinkRepository,
+        getAssetRepository: provider.getAssetRepository,
+        getAssetVersionRepository: provider.getAssetVersionRepository,
+        getEmbedRepository: provider.getEmbedRepository,
+        getPageEmbedLinkRepository: provider.getPageEmbedLinkRepository,
+        getAll: provider.getAll,
+        createAll: provider.createAll,
+        clearServiceCache: provider.clearServiceCache,
+        clearDocumentServiceCache: provider.clearDocumentServiceCache,
+        clearDocumentGroupServiceCache: provider.clearDocumentGroupServiceCache,
+        clearDocumentVersionServiceCache: provider.clearDocumentVersionServiceCache,
+        clearSectionServiceCache: provider.clearSectionServiceCache,
+        clearPageServiceCache: provider.clearPageServiceCache,
+        clearPageVersionServiceCache: provider.clearPageVersionServiceCache,
+        clearDocumentSectionLinkServiceCache: provider.clearDocumentSectionLinkServiceCache,
+        clearSectionPageLinkServiceCache: provider.clearSectionPageLinkServiceCache,
+        clearSnippetServiceCache: provider.clearSnippetServiceCache,
+        clearPageSnippetLinkServiceCache: provider.clearPageSnippetLinkServiceCache,
+        clearAssetServiceCache: provider.clearAssetServiceCache,
+        clearAssetVersionServiceCache: provider.clearAssetVersionServiceCache,
+        clearEmbedServiceCache: provider.clearEmbedServiceCache,
+        clearPageEmbedLinkServiceCache: provider.clearPageEmbedLinkServiceCache,
+        reset: provider.reset,
+        getRegistryStats: provider.getRegistryStats,
+        resolveLogger: provider.resolveLogger,
+        withContext(overrides) {
+            return {
+                getStaticConfig() {
+                    return options.staticConfig;
+                },
+                getDocumentService: (o) => provider.getDocumentService({ ...overrides, ...o }),
+                getDocumentGroupService: (o) => provider.getDocumentGroupService({ ...overrides, ...o }),
+                getDocumentVersionService: (o) => provider.getDocumentVersionService({ ...overrides, ...o }),
+                getSectionService: (o) => provider.getSectionService({ ...overrides, ...o }),
+                getPageService: (o) => provider.getPageService({ ...overrides, ...o }),
+                getPageVersionService: (o) => provider.getPageVersionService({ ...overrides, ...o }),
+                getDocumentSectionLinkService: (o) => provider.getDocumentSectionLinkService({ ...overrides, ...o }),
+                getSectionPageLinkService: (o) => provider.getSectionPageLinkService({ ...overrides, ...o }),
+                getSnippetService: (o) => provider.getSnippetService({ ...overrides, ...o }),
+                getPageSnippetLinkService: (o) => provider.getPageSnippetLinkService({ ...overrides, ...o }),
+                getAssetService: (o) => provider.getAssetService({ ...overrides, ...o }),
+                getAssetVersionService: (o) => provider.getAssetVersionService({ ...overrides, ...o }),
+                getEmbedService: (o) => provider.getEmbedService({ ...overrides, ...o }),
+                getPageEmbedLinkService: (o) => provider.getPageEmbedLinkService({ ...overrides, ...o }),
+                getDocumentRepository: (o) => provider.getDocumentRepository({ ...overrides, ...o }),
+                getDocumentGroupRepository: (o) => provider.getDocumentGroupRepository({ ...overrides, ...o }),
+                getDocumentVersionRepository: (o) => provider.getDocumentVersionRepository({ ...overrides, ...o }),
+                getSectionRepository: (o) => provider.getSectionRepository({ ...overrides, ...o }),
+                getPageRepository: (o) => provider.getPageRepository({ ...overrides, ...o }),
+                getPageVersionRepository: (o) => provider.getPageVersionRepository({ ...overrides, ...o }),
+                getDocumentIndexEntryRepository: (o) => provider.getDocumentIndexEntryRepository({ ...overrides, ...o }),
+                getDocumentSectionLinkRepository: (o) => provider.getDocumentSectionLinkRepository({ ...overrides, ...o }),
+                getSectionPageLinkRepository: (o) => provider.getSectionPageLinkRepository({ ...overrides, ...o }),
+                getSnippetRepository: (o) => provider.getSnippetRepository({ ...overrides, ...o }),
+                getPageSnippetLinkRepository: (o) => provider.getPageSnippetLinkRepository({ ...overrides, ...o }),
+                getAssetRepository: (o) => provider.getAssetRepository({ ...overrides, ...o }),
+                getAssetVersionRepository: (o) => provider.getAssetVersionRepository({ ...overrides, ...o }),
+                getEmbedRepository: (o) => provider.getEmbedRepository({ ...overrides, ...o }),
+                getPageEmbedLinkRepository: (o) => provider.getPageEmbedLinkRepository({ ...overrides, ...o }),
+                getAll: (o) => provider.getAll({ ...overrides, ...o }),
+                createAll: (o) => provider.createAll({ ...overrides, ...o }),
+                clearServiceCache: (cacheKey) => provider.clearServiceCache(cacheKey),
+                clearDocumentServiceCache: (cacheKey) => provider.clearDocumentServiceCache(cacheKey),
+                clearDocumentGroupServiceCache: (cacheKey) => provider.clearDocumentGroupServiceCache(cacheKey),
+                clearDocumentVersionServiceCache: (cacheKey) => provider.clearDocumentVersionServiceCache(cacheKey),
+                clearSectionServiceCache: (cacheKey) => provider.clearSectionServiceCache(cacheKey),
+                clearPageServiceCache: (cacheKey) => provider.clearPageServiceCache(cacheKey),
+                clearPageVersionServiceCache: (cacheKey) => provider.clearPageVersionServiceCache(cacheKey),
+                clearDocumentSectionLinkServiceCache: (cacheKey) => provider.clearDocumentSectionLinkServiceCache(cacheKey),
+                clearSectionPageLinkServiceCache: (cacheKey) => provider.clearSectionPageLinkServiceCache(cacheKey),
+                clearSnippetServiceCache: (cacheKey) => provider.clearSnippetServiceCache(cacheKey),
+                clearPageSnippetLinkServiceCache: (cacheKey) => provider.clearPageSnippetLinkServiceCache(cacheKey),
+                clearAssetServiceCache: (cacheKey) => provider.clearAssetServiceCache(cacheKey),
+                clearAssetVersionServiceCache: (cacheKey) => provider.clearAssetVersionServiceCache(cacheKey),
+                clearEmbedServiceCache: (cacheKey) => provider.clearEmbedServiceCache(cacheKey),
+                clearPageEmbedLinkServiceCache: (cacheKey) => provider.clearPageEmbedLinkServiceCache(cacheKey),
+                reset: (opts) => provider.reset(opts),
+                getRegistryStats: () => provider.getRegistryStats(),
+                resolveLogger: (o) => provider.resolveLogger({ ...overrides, ...o }),
+            };
+        },
+    };
+}
+export function buildDocmanKitStaticConfig(envConfig) {
+    return {
+        logLevel: envConfig.logLevel,
+        documentRepository: { repositoryType: inferRepositoryType(envConfig.documentRepoUrl), url: envConfig.documentRepoUrl },
+        documentGroupRepository: { repositoryType: inferRepositoryType(envConfig.documentGroupRepoUrl), url: envConfig.documentGroupRepoUrl },
+        documentVersionRepository: { repositoryType: inferRepositoryType(envConfig.documentVersionRepoUrl), url: envConfig.documentVersionRepoUrl },
+        sectionRepository: { repositoryType: inferRepositoryType(envConfig.sectionRepoUrl), url: envConfig.sectionRepoUrl },
+        pageRepository: { repositoryType: inferRepositoryType(envConfig.pageRepoUrl), url: envConfig.pageRepoUrl },
+        pageVersionRepository: { repositoryType: inferRepositoryType(envConfig.pageVersionRepoUrl), url: envConfig.pageVersionRepoUrl },
+        documentIndexEntryRepository: {
+            repositoryType: inferRepositoryType(envConfig.documentRepoUrl),
+            url: envConfig.documentRepoUrl,
+        },
+        documentSectionLinkRepository: { repositoryType: inferRepositoryType(envConfig.documentSectionLinkRepoUrl), url: envConfig.documentSectionLinkRepoUrl },
+        sectionPageLinkRepository: { repositoryType: inferRepositoryType(envConfig.sectionPageLinkRepoUrl), url: envConfig.sectionPageLinkRepoUrl },
+        snippetRepository: { repositoryType: inferRepositoryType(envConfig.snippetRepoUrl), url: envConfig.snippetRepoUrl },
+        pageSnippetLinkRepository: { repositoryType: inferRepositoryType(envConfig.pageSnippetLinkRepoUrl), url: envConfig.pageSnippetLinkRepoUrl },
+        assetRepository: { repositoryType: inferRepositoryType(envConfig.assetRepoUrl), url: envConfig.assetRepoUrl },
+        assetVersionRepository: { repositoryType: inferRepositoryType(envConfig.assetVersionRepoUrl), url: envConfig.assetVersionRepoUrl },
+        embedRepository: { repositoryType: inferRepositoryType(envConfig.embedRepoUrl), url: envConfig.embedRepoUrl },
+        pageEmbedLinkRepository: { repositoryType: inferRepositoryType(envConfig.pageEmbedLinkRepoUrl), url: envConfig.pageEmbedLinkRepoUrl },
+    };
+}
+export function createDocmanKitWithEnv(options) {
+    const staticConfig = buildDocmanKitStaticConfig(options.envConfig);
+    const envCfg = parseEnvConfig();
+    const statsEnabled = envCfg.statsEnabled === true;
+    const counters = statsEnabled ? new CountersMetricsCollector() : undefined;
+    const loggerMetrics = statsEnabled ? new LoggerMetricsCollector(undefined) : undefined;
+    const metricsCollector = options.metrics ?? (counters && loggerMetrics ? new MultiMetricsCollector([counters, loggerMetrics]) : counters ?? loggerMetrics);
+    const cacheMerged = (options.cache || envCfg.cacheGlobal)
+        ? { ...(options.cache ?? {}), ...(envCfg.cacheGlobal ?? {}) }
+        : undefined;
+    const resilienceMerged = (options.resilience || envCfg.resilience)
+        ? ({ ...(options.resilience ?? {}), ...(envCfg.resilience ?? {}) })
+        : undefined;
+    const kit = createDocmanKit({
+        name: options.name ?? 'docman-kit',
+        staticConfig,
+        getContext: (overrides) => ({
+            tenantId: options.baseContext.tenantId,
+            locale: options.baseContext.locale,
+            fallbackLocale: options.baseContext.fallbackLocale,
+            ...overrides,
+            logger: overrides?.logger ?? options.baseContext.logger,
+        }),
+        resolveLogger: (ctx) => options.resolveLogger?.(ctx) ?? ctx.logger ?? options.baseContext.logger,
+        getCacheKey: (ctx) => options.getCacheKey?.(ctx) ?? cacheKeyFromLocale(ctx.locale, ctx.fallbackLocale),
+        cache: cacheMerged,
+        metrics: metricsCollector,
+        resilience: resilienceMerged,
+        transformService: options.transformService,
+    });
+    return {
+        kit,
+        getMetricsSnapshot: () => (counters ? counters.snapshot() : null),
+        validate: async () => {
+            const svc = await kit.createAll();
+            void svc;
+            return Effect.succeed(true);
+        },
+    };
+}

package/dist/errors/error.map.d.ts

@@ -0,0 +1,21 @@
+import { KeysOf } from '@aopslab/xf-i18n';
+import { BmResourceInline } from '@aopslab/xf-i18n/bm';
+import { type XfFriendlyError } from './friendly.js';
+import { type ILabelsDocmanServerErrorsTags } from '../resources/index.js';
+export type TranslateOptions = {
+    locale?: string;
+    defaultLocale?: string;
+    overrideResourceWith?: BmResourceInline<never, ILabelsDocmanServerErrorsTags>;
+};
+type DocmanErrorTagKey = KeysOf<ILabelsDocmanServerErrorsTags>;
+export declare function mapErrorToFriendly(error: unknown, translateOpts?: TranslateOptions): XfFriendlyError & {
+    message: string;
+};
+export declare function mapErrorToFriendlyText(error: unknown, translateOpts?: TranslateOptions): {
+    translatedMessageText: string;
+    translationKey: DocmanErrorTagKey;
+    errorCode?: string;
+    domainTag?: string;
+    friendly: XfFriendlyError;
+};
+export {};

package/dist/errors/error.map.js

@@ -0,0 +1,47 @@
+import { I18nBm } from '@aopslab/xf-i18n/bm';
+import { toFriendlyError, } from './friendly.js';
+import { docmanErrorsResources, } from '../resources/index.js';
+const FALLBACK_KEY = 'error__unexpected';
+function resolvePrimaryKey(friendly) {
+    const first = friendly.messages[0]?.key;
+    if (!first)
+        return FALLBACK_KEY;
+    const tags = docmanErrorsResources.tags ?? {};
+    if (first in tags)
+        return first;
+    return FALLBACK_KEY;
+}
+function translateKey(key, translateOpts) {
+    const locale = translateOpts?.locale ?? 'en';
+    const defaultLocale = translateOpts?.defaultLocale ?? 'en';
+    const i18nBm = new I18nBm({
+        inlineResources: translateOpts?.overrideResourceWith ?? docmanErrorsResources,
+        config: {
+            defaultLocale,
+            fallbackLocale: defaultLocale,
+        },
+    });
+    const t = i18nBm.getTagTranslator({ locale });
+    return t(key);
+}
+export function mapErrorToFriendly(error, translateOpts) {
+    const friendly = toFriendlyError(error);
+    const translationKey = resolvePrimaryKey(friendly);
+    const message = translateKey(translationKey, translateOpts);
+    return {
+        ...friendly,
+        message,
+    };
+}
+export function mapErrorToFriendlyText(error, translateOpts) {
+    const friendly = toFriendlyError(error);
+    const translationKey = resolvePrimaryKey(friendly);
+    const translatedMessageText = translateKey(translationKey, translateOpts);
+    return {
+        translatedMessageText,
+        translationKey,
+        errorCode: friendly.code,
+        domainTag: friendly.scope,
+        friendly,
+    };
+}

package/dist/errors/friendly.d.ts

@@ -0,0 +1,31 @@
+import { XfResult } from '@aopslab/xf-core';
+export type FriendlyMessageType = 'error' | 'validation';
+export interface FriendlyMessage {
+    key: string;
+    field?: string;
+    params?: Record<string, string>;
+    type?: FriendlyMessageType;
+}
+export interface XfFriendlyError {
+    scope: string;
+    code: string;
+    status?: number;
+    severity: 'user' | 'system';
+    messages: FriendlyMessage[];
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    trace?: {
+        stage?: string;
+        operation?: string;
+    };
+    cause?: unknown;
+}
+export declare function toFriendlyError(inputError: unknown): XfFriendlyError;
+export declare function friendlyErrorToResult<TData = unknown>(friendly: XfFriendlyError): XfResult<TData, XfFriendlyError>;
+export declare function friendlyErrorToResultI18n<TData = unknown, TKey extends string = string>(friendly: XfFriendlyError, t: (key: TKey, params?: Record<string, string>) => string): XfResult<TData, XfFriendlyError>;
+export declare function friendlyErrorToHttpBody(friendly: XfFriendlyError): {
+    ok: false;
+    code: string;
+    severity: "user" | "system";
+    messages: FriendlyMessage[];
+};
+export declare function errorToResult<TData = unknown>(error: unknown): XfResult<TData, XfFriendlyError>;