@aopslab/domain-dm-docman 0.1.2

package/dist/application/services/documentComposeSupport.d.ts

@@ -0,0 +1,30 @@
+export declare const DOCMAN_COMPOSE_SOURCE_FORMATS: readonly ["md", "mdx"];
+export type DocmanComposeSourceFormat = (typeof DOCMAN_COMPOSE_SOURCE_FORMATS)[number];
+export type ParsedDocmanAssetReferenceToken = {
+    token: string;
+    ref: string;
+    version: number | null;
+};
+export type DocmanComposeSourceContentParts = {
+    modulePreamble?: string;
+    body: string;
+};
+export declare function isDocmanComposeSourceFormat(value: unknown): value is DocmanComposeSourceFormat;
+export declare function resolveDocmanComposeSourceFormat(value: unknown): DocmanComposeSourceFormat | null;
+export declare function reduceDocmanComposeFormats(values: Iterable<unknown>): {
+    format: DocmanComposeSourceFormat;
+    formats: DocmanComposeSourceFormat[];
+};
+export declare function listDocmanAssetReferenceTokens(content: string): ParsedDocmanAssetReferenceToken[];
+export declare function replaceDocmanAssetReferenceTokens(content: string, resolver: (token: ParsedDocmanAssetReferenceToken) => string): string;
+export declare function normalizeDocmanComposeSourceContent(format: DocmanComposeSourceFormat, content: string): string;
+export declare function splitDocmanComposeSourceContent(format: DocmanComposeSourceFormat, content: string): DocmanComposeSourceContentParts;
+/**
+ * Strip a stored title's legacy heading prefix when the renderer is about to
+ * prepend a freshly computed outline number. Mirrors the desktop UI helper
+ * `formatDocmanDisplayTitle` (apps/aops-desktop/src/pages/docman/lib/docman-display-title.ts):
+ * returns the raw title untouched when there is no computed number, when the
+ * computed number stringifies to '0', when the title is empty, or when
+ * stripping would leave an empty string.
+ */
+export declare function stripLeadingNumericPrefixForRender(title: unknown, computedNumber: unknown): string;

package/dist/application/services/documentComposeSupport.js

@@ -0,0 +1,285 @@
+import { parseDocmanAssetReference, resolveDocmanPageSourceFormat, } from '@aopslab/domain-core-docman';
+export const DOCMAN_COMPOSE_SOURCE_FORMATS = ['md', 'mdx'];
+const DOCMAN_ASSET_REFERENCE_TOKEN_RE = /(asset:\/\/[A-Za-z0-9][A-Za-z0-9._:-]*(?:@[0-9]+)?)/g;
+const MDX_MODULE_LINE_RE = /^\s*(?:import|export)\b/;
+export function isDocmanComposeSourceFormat(value) {
+    return value === 'md' || value === 'mdx';
+}
+export function resolveDocmanComposeSourceFormat(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    const sourceFormat = resolveDocmanPageSourceFormat(normalized);
+    if (normalized !== sourceFormat)
+        return null;
+    return isDocmanComposeSourceFormat(sourceFormat) ? sourceFormat : null;
+}
+export function reduceDocmanComposeFormats(values) {
+    const seen = new Set();
+    for (const value of values) {
+        const format = resolveDocmanComposeSourceFormat(value);
+        if (format)
+            seen.add(format);
+    }
+    const formats = [...seen].sort((left, right) => left.localeCompare(right));
+    return {
+        format: formats.includes('mdx') ? 'mdx' : 'md',
+        formats: formats.length > 0 ? formats : ['md'],
+    };
+}
+export function listDocmanAssetReferenceTokens(content) {
+    const text = String(content ?? '');
+    if (!text)
+        return [];
+    const byToken = new Map();
+    forEachDocmanAssetReferenceTokenOutsideMarkdownCode(text, (token) => {
+        if (!token || byToken.has(token))
+            return;
+        const parsed = parseDocmanAssetReferenceToken(token);
+        if (!parsed)
+            return;
+        byToken.set(token, parsed);
+    });
+    return [...byToken.values()];
+}
+export function replaceDocmanAssetReferenceTokens(content, resolver) {
+    const text = String(content ?? '');
+    if (!text)
+        return text;
+    return mapDocmanAssetReferenceTokensOutsideMarkdownCode(text, (token) => {
+        const parsed = parseDocmanAssetReferenceToken(token);
+        if (!parsed)
+            return token;
+        return resolver(parsed);
+    });
+}
+export function normalizeDocmanComposeSourceContent(format, content) {
+    const text = String(content ?? '');
+    if (format !== 'mdx' || !text)
+        return text;
+    return text;
+}
+export function splitDocmanComposeSourceContent(format, content) {
+    const text = String(content ?? '');
+    if (format !== 'mdx' || !text) {
+        return { body: text };
+    }
+    const lines = text.split(/\r?\n/);
+    let index = 0;
+    const moduleLines = [];
+    while (index < lines.length) {
+        const current = String(lines[index] ?? '');
+        if (!current.trim()) {
+            if (moduleLines.length > 0 && moduleLines[moduleLines.length - 1] !== '') {
+                moduleLines.push('');
+            }
+            index += 1;
+            continue;
+        }
+        if (!MDX_MODULE_LINE_RE.test(current)) {
+            break;
+        }
+        const statementStart = index;
+        index += 1;
+        while (index < lines.length) {
+            const statementLine = String(lines[index - 1] ?? '').trim();
+            if (!statementLine || statementLine.endsWith(';'))
+                break;
+            const nextLine = String(lines[index] ?? '');
+            index += 1;
+            if (!nextLine.trim())
+                break;
+            if (String(nextLine).trim().endsWith(';'))
+                break;
+        }
+        moduleLines.push(...lines.slice(statementStart, index));
+        while (index < lines.length && !String(lines[index] ?? '').trim()) {
+            if (moduleLines[moduleLines.length - 1] !== '') {
+                moduleLines.push('');
+            }
+            index += 1;
+        }
+    }
+    const modulePreamble = moduleLines.join('\n').trim();
+    return {
+        modulePreamble: modulePreamble || undefined,
+        body: lines.slice(index).join('\n').trimStart(),
+    };
+}
+function parseDocmanAssetReferenceToken(token) {
+    const normalized = String(token ?? '').trim();
+    const parsed = parseDocmanAssetReference(normalized);
+    if (!parsed)
+        return null;
+    return {
+        token: normalized,
+        ref: parsed.assetUid,
+        version: Number.isInteger(parsed.version) && Number(parsed.version) > 0 ? Number(parsed.version) : null,
+    };
+}
+function forEachDocmanAssetReferenceTokenOutsideMarkdownCode(text, visitor) {
+    for (const segment of listDocmanTextSegmentsOutsideMarkdownCode(text)) {
+        const matches = segment.matchAll(DOCMAN_ASSET_REFERENCE_TOKEN_RE);
+        for (const match of matches) {
+            const token = String(match[1] ?? '').trim();
+            if (token)
+                visitor(token);
+        }
+    }
+}
+function mapDocmanAssetReferenceTokensOutsideMarkdownCode(text, mapper) {
+    const ranges = listMarkdownCodeRanges(text);
+    if (ranges.length === 0) {
+        return text.replace(DOCMAN_ASSET_REFERENCE_TOKEN_RE, (token) => mapper(token));
+    }
+    let cursor = 0;
+    let next = '';
+    for (const range of ranges) {
+        if (cursor < range.start) {
+            next += text.slice(cursor, range.start).replace(DOCMAN_ASSET_REFERENCE_TOKEN_RE, (token) => mapper(token));
+        }
+        next += text.slice(range.start, range.end);
+        cursor = range.end;
+    }
+    if (cursor < text.length) {
+        next += text.slice(cursor).replace(DOCMAN_ASSET_REFERENCE_TOKEN_RE, (token) => mapper(token));
+    }
+    return next;
+}
+function listDocmanTextSegmentsOutsideMarkdownCode(text) {
+    const ranges = listMarkdownCodeRanges(text);
+    if (ranges.length === 0)
+        return [text];
+    const segments = [];
+    let cursor = 0;
+    for (const range of ranges) {
+        if (cursor < range.start) {
+            segments.push(text.slice(cursor, range.start));
+        }
+        cursor = range.end;
+    }
+    if (cursor < text.length) {
+        segments.push(text.slice(cursor));
+    }
+    return segments;
+}
+function listMarkdownCodeRanges(text) {
+    if (!text)
+        return [];
+    const ranges = [];
+    const length = text.length;
+    let index = 0;
+    let fencedStart = -1;
+    let fencedMarker = '';
+    let inlineStart = -1;
+    let inlineTicks = 0;
+    while (index < length) {
+        if (fencedStart >= 0) {
+            if (isLineStart(text, index)) {
+                const fence = readFenceMarkerAt(text, index);
+                if (fence && fence.marker[0] === fencedMarker[0] && fence.marker.length >= fencedMarker.length) {
+                    const lineEnd = readLineEnd(text, index);
+                    ranges.push({ start: fencedStart, end: lineEnd });
+                    fencedStart = -1;
+                    fencedMarker = '';
+                    index = lineEnd;
+                    continue;
+                }
+            }
+            index += 1;
+            continue;
+        }
+        if (inlineStart >= 0) {
+            const tickCount = readBacktickRunLength(text, index);
+            if (tickCount === inlineTicks) {
+                ranges.push({ start: inlineStart, end: index + tickCount });
+                inlineStart = -1;
+                inlineTicks = 0;
+                index += tickCount;
+                continue;
+            }
+            index += 1;
+            continue;
+        }
+        if (isLineStart(text, index)) {
+            const fence = readFenceMarkerAt(text, index);
+            if (fence) {
+                fencedStart = index;
+                fencedMarker = fence.marker;
+                index = fence.contentStart;
+                continue;
+            }
+        }
+        const tickCount = readBacktickRunLength(text, index);
+        if (tickCount > 0) {
+            inlineStart = index;
+            inlineTicks = tickCount;
+            index += tickCount;
+            continue;
+        }
+        index += 1;
+    }
+    if (inlineStart >= 0) {
+        ranges.push({ start: inlineStart, end: length });
+    }
+    if (fencedStart >= 0) {
+        ranges.push({ start: fencedStart, end: length });
+    }
+    return ranges;
+}
+function isLineStart(text, index) {
+    return index <= 0 || text[index - 1] === '\n';
+}
+function readLineEnd(text, index) {
+    const newlineIndex = text.indexOf('\n', index);
+    return newlineIndex >= 0 ? newlineIndex + 1 : text.length;
+}
+function readBacktickRunLength(text, index) {
+    if (text[index] !== '`')
+        return 0;
+    let cursor = index;
+    while (cursor < text.length && text[cursor] === '`') {
+        cursor += 1;
+    }
+    return cursor - index;
+}
+function readFenceMarkerAt(text, index) {
+    let cursor = index;
+    let indentation = 0;
+    while (cursor < text.length && indentation < 4 && (text[cursor] === ' ' || text[cursor] === '\t')) {
+        cursor += 1;
+        indentation += 1;
+    }
+    const fenceChar = text[cursor];
+    if (fenceChar !== '`' && fenceChar !== '~')
+        return null;
+    let markerEnd = cursor;
+    while (markerEnd < text.length && text[markerEnd] === fenceChar) {
+        markerEnd += 1;
+    }
+    const marker = text.slice(cursor, markerEnd);
+    if (marker.length < 3)
+        return null;
+    return { marker, contentStart: markerEnd };
+}
+const LEADING_NUMERIC_PREFIX_PATTERN = /^\s*\d+(?:\.\d+)*[.)]?\s+/;
+/**
+ * Strip a stored title's legacy heading prefix when the renderer is about to
+ * prepend a freshly computed outline number. Mirrors the desktop UI helper
+ * `formatDocmanDisplayTitle` (apps/aops-desktop/src/pages/docman/lib/docman-display-title.ts):
+ * returns the raw title untouched when there is no computed number, when the
+ * computed number stringifies to '0', when the title is empty, or when
+ * stripping would leave an empty string.
+ */
+export function stripLeadingNumericPrefixForRender(title, computedNumber) {
+    const rawTitle = String(title ?? '').trim();
+    if (!rawTitle)
+        return rawTitle;
+    const number = String(computedNumber ?? '').trim();
+    if (!number || number === '0')
+        return rawTitle;
+    const stripped = rawTitle.replace(LEADING_NUMERIC_PREFIX_PATTERN, '').trim();
+    return stripped || rawTitle;
+}

package/dist/application/services/documentIndexSupport.d.ts

@@ -0,0 +1,7 @@
+export declare const DOCMAN_DOCUMENT_INDEX_BUILD_ACTOR = "docman.index.build";
+export declare function normalizeDocmanDocumentIndexLocale(value: unknown): string;
+export declare function slugifyDocmanDocumentIndexPart(value: unknown, fallback: string): string;
+export declare function buildDocmanDocumentAnchor(documentIdentity: unknown): string;
+export declare function buildDocmanSectionAnchor(sectionIdentity: unknown, linkId: unknown): string;
+export declare function buildDocmanPageAnchor(pageIdentity: unknown, linkId: unknown): string;
+export declare function buildDocmanDocumentIndexFingerprint(value: unknown): string;

package/dist/application/services/documentIndexSupport.js

@@ -0,0 +1,28 @@
+import { createHash } from 'node:crypto';
+export const DOCMAN_DOCUMENT_INDEX_BUILD_ACTOR = 'docman.index.build';
+function normalizeNonEmpty(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+export function normalizeDocmanDocumentIndexLocale(value) {
+    return normalizeNonEmpty(value);
+}
+export function slugifyDocmanDocumentIndexPart(value, fallback) {
+    const normalized = normalizeNonEmpty(value).toLowerCase();
+    const slug = normalized
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+/, '')
+        .replace(/-+$/, '');
+    return slug || fallback;
+}
+export function buildDocmanDocumentAnchor(documentIdentity) {
+    return `document-${slugifyDocmanDocumentIndexPart(documentIdentity, 'document')}`;
+}
+export function buildDocmanSectionAnchor(sectionIdentity, linkId) {
+    return `section-${slugifyDocmanDocumentIndexPart(sectionIdentity, 'section')}-${slugifyDocmanDocumentIndexPart(linkId, 'link')}`;
+}
+export function buildDocmanPageAnchor(pageIdentity, linkId) {
+    return `page-${slugifyDocmanDocumentIndexPart(pageIdentity, 'page')}-${slugifyDocmanDocumentIndexPart(linkId, 'link')}`;
+}
+export function buildDocmanDocumentIndexFingerprint(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}

package/dist/application/services/documentPublishSupport.d.ts

@@ -0,0 +1,14 @@
+import type { DocmanPublishTarget } from '../ports/inbound/IDocumentServicePort.js';
+export declare const DOCMAN_PUBLISH_TARGETS: readonly ["markdown", "html"];
+export type DocmanPublishDeliveryKind = 'inline-text';
+export type DocmanPublishTargetDescriptor = {
+    target: DocmanPublishTarget;
+    deliveryKind: DocmanPublishDeliveryKind;
+    mediaType: string;
+};
+export declare function listDocmanPublishTargets(): DocmanPublishTarget[];
+export declare function formatDocmanPublishTargets(): string;
+export declare function isDocmanPublishTarget(value: unknown): value is DocmanPublishTarget;
+export declare function resolveDocmanPublishTarget(value: unknown): DocmanPublishTarget | null;
+export declare function resolveDocmanPublishTargetDescriptor(value: unknown): DocmanPublishTargetDescriptor | null;
+export declare function getDocmanPublishTargetDescriptor(target: DocmanPublishTarget): DocmanPublishTargetDescriptor;

package/dist/application/services/documentPublishSupport.js

@@ -0,0 +1,39 @@
+export const DOCMAN_PUBLISH_TARGETS = ['markdown', 'html'];
+const DOCMAN_PUBLISH_TARGET_DESCRIPTOR_MAP = {
+    markdown: {
+        target: 'markdown',
+        deliveryKind: 'inline-text',
+        mediaType: 'text/markdown; charset=utf-8',
+    },
+    html: {
+        target: 'html',
+        deliveryKind: 'inline-text',
+        mediaType: 'text/html; charset=utf-8',
+    },
+};
+export function listDocmanPublishTargets() {
+    return [...DOCMAN_PUBLISH_TARGETS];
+}
+export function formatDocmanPublishTargets() {
+    return listDocmanPublishTargets().join(', ');
+}
+export function isDocmanPublishTarget(value) {
+    return resolveDocmanPublishTarget(value) !== null;
+}
+export function resolveDocmanPublishTarget(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    return normalized === 'markdown' || normalized === 'html'
+        ? normalized
+        : null;
+}
+export function resolveDocmanPublishTargetDescriptor(value) {
+    const target = resolveDocmanPublishTarget(value);
+    return target ? getDocmanPublishTargetDescriptor(target) : null;
+}
+export function getDocmanPublishTargetDescriptor(target) {
+    return DOCMAN_PUBLISH_TARGET_DESCRIPTOR_MAP[target];
+}

package/dist/application/services/documentRetrievalAiSupport.d.ts

@@ -0,0 +1,21 @@
+export type DocmanEmbeddingProviderResult = {
+    provider: string;
+    model: string;
+    dimensions: number;
+    vectors: number[][];
+};
+export type DocmanEmbeddingProvider = {
+    provider: string;
+    model: string;
+    dimensions?: number;
+    embedMany(input: {
+        texts: readonly string[];
+    }): Promise<DocmanEmbeddingProviderResult>;
+};
+export declare function buildDocmanEmbeddingHash(value: string): string;
+export declare function serializeDocmanEmbeddingVector(vector: readonly number[]): string;
+export declare function parseDocmanEmbeddingVector(value: unknown): number[] | undefined;
+export declare function cosineSimilarity(left: readonly number[], right: readonly number[]): number;
+export declare function buildDocmanLocalHashVector(value: string, dimensions?: number): number[];
+export declare function createDocmanLocalHashEmbeddingProvider(): DocmanEmbeddingProvider;
+export declare function resolveDocmanDefaultEmbeddingProvider(): DocmanEmbeddingProvider;

package/dist/application/services/documentRetrievalAiSupport.js

@@ -0,0 +1,114 @@
+import { createHash } from 'node:crypto';
+const DOCMAN_LOCAL_EMBEDDING_PROVIDER = 'docman-local-hash-v1';
+const DOCMAN_LOCAL_EMBEDDING_MODEL = 'hash-256';
+const DOCMAN_LOCAL_EMBEDDING_DIMENSIONS = 256;
+function normalizeText(value) {
+    return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+function normalizeEmbeddingText(value) {
+    return normalizeText(value).toLowerCase();
+}
+function buildStableBucket(seed, dimensions) {
+    const digest = createHash('sha1').update(seed).digest();
+    const index = digest.readUInt32BE(0) % dimensions;
+    const sign = digest[4] % 2 === 0 ? 1 : -1;
+    return { index, sign };
+}
+function normalizeVector(input) {
+    const magnitude = Math.sqrt(input.reduce((sum, value) => sum + value * value, 0));
+    if (!Number.isFinite(magnitude) || magnitude <= 0) {
+        return Array.from({ length: input.length }, () => 0);
+    }
+    return input.map((value) => Number((value / magnitude).toFixed(8)));
+}
+function listWordTokens(value) {
+    return [...new Set(value.split(/\s+/).map((token) => token.trim()).filter(Boolean))];
+}
+function listCharacterNgrams(value, size = 3) {
+    const compact = value.replace(/\s+/g, ' ');
+    if (compact.length < size) {
+        return compact ? [compact] : [];
+    }
+    const output = new Set();
+    for (let index = 0; index <= compact.length - size; index += 1) {
+        output.add(compact.slice(index, index + size));
+    }
+    return [...output];
+}
+export function buildDocmanEmbeddingHash(value) {
+    return createHash('sha256').update(normalizeEmbeddingText(value)).digest('hex');
+}
+export function serializeDocmanEmbeddingVector(vector) {
+    return JSON.stringify(vector.map((value) => Number(Number(value).toFixed(8))));
+}
+export function parseDocmanEmbeddingVector(value) {
+    const raw = normalizeText(value);
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return undefined;
+        const numbers = parsed
+            .map((entry) => Number(entry))
+            .filter((entry) => Number.isFinite(entry));
+        return numbers.length === parsed.length && numbers.length > 0 ? numbers : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function cosineSimilarity(left, right) {
+    if (!left.length || !right.length || left.length !== right.length)
+        return 0;
+    let sum = 0;
+    let leftMagnitude = 0;
+    let rightMagnitude = 0;
+    for (let index = 0; index < left.length; index += 1) {
+        const leftValue = Number(left[index] ?? 0);
+        const rightValue = Number(right[index] ?? 0);
+        sum += leftValue * rightValue;
+        leftMagnitude += leftValue * leftValue;
+        rightMagnitude += rightValue * rightValue;
+    }
+    if (leftMagnitude <= 0 || rightMagnitude <= 0)
+        return 0;
+    return sum / Math.sqrt(leftMagnitude * rightMagnitude);
+}
+export function buildDocmanLocalHashVector(value, dimensions = DOCMAN_LOCAL_EMBEDDING_DIMENSIONS) {
+    const normalized = normalizeEmbeddingText(value);
+    if (!normalized) {
+        return Array.from({ length: dimensions }, () => 0);
+    }
+    const vector = Array.from({ length: dimensions }, () => 0);
+    const tokens = listWordTokens(normalized);
+    const ngrams = listCharacterNgrams(normalized, 3);
+    for (const token of tokens) {
+        const { index, sign } = buildStableBucket(`token:${token}`, dimensions);
+        vector[index] += 2.4 * sign;
+    }
+    for (const ngram of ngrams) {
+        const { index, sign } = buildStableBucket(`ngram:${ngram}`, dimensions);
+        vector[index] += 0.8 * sign;
+    }
+    return normalizeVector(vector);
+}
+export function createDocmanLocalHashEmbeddingProvider() {
+    return {
+        provider: DOCMAN_LOCAL_EMBEDDING_PROVIDER,
+        model: DOCMAN_LOCAL_EMBEDDING_MODEL,
+        dimensions: DOCMAN_LOCAL_EMBEDDING_DIMENSIONS,
+        async embedMany(input) {
+            const texts = Array.isArray(input.texts) ? input.texts : [];
+            return {
+                provider: DOCMAN_LOCAL_EMBEDDING_PROVIDER,
+                model: DOCMAN_LOCAL_EMBEDDING_MODEL,
+                dimensions: DOCMAN_LOCAL_EMBEDDING_DIMENSIONS,
+                vectors: texts.map((text) => buildDocmanLocalHashVector(text)),
+            };
+        },
+    };
+}
+export function resolveDocmanDefaultEmbeddingProvider() {
+    return createDocmanLocalHashEmbeddingProvider();
+}

package/dist/application/services/index.d.ts

@@ -0,0 +1,14 @@
+export * from './service.document.js';
+export * from './service.documentGroup.js';
+export * from './service.documentVersion.js';
+export * from './service.section.js';
+export * from './service.page.js';
+export * from './service.pageVersion.js';
+export * from './service.documentSectionLink.js';
+export * from './service.sectionPageLink.js';
+export * from './service.snippet.js';
+export * from './service.pageSnippetLink.js';
+export * from './service.asset.js';
+export * from './service.assetVersion.js';
+export * from './service.embed.js';
+export * from './service.pageEmbedLink.js';

package/dist/application/services/index.js

@@ -0,0 +1,15 @@
+// Auto-generated by xf-gen
+export * from './service.document.js';
+export * from './service.documentGroup.js';
+export * from './service.documentVersion.js';
+export * from './service.section.js';
+export * from './service.page.js';
+export * from './service.pageVersion.js';
+export * from './service.documentSectionLink.js';
+export * from './service.sectionPageLink.js';
+export * from './service.snippet.js';
+export * from './service.pageSnippetLink.js';
+export * from './service.asset.js';
+export * from './service.assetVersion.js';
+export * from './service.embed.js';
+export * from './service.pageEmbedLink.js';

package/dist/application/services/service.asset.d.ts

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import { DbQueryOptions } from '@aopslab/xf-db';
+import type { IRepositoryPortAsset } from '../ports/repository-ports/index.js';
+import type { IAssetServicePort } from '../ports/inbound/index.js';
+import { AssetServiceError } from '../errors/AssetServiceError.js';
+import { IbmAsset, IbmAssetInsert } from '../../domain/models/index.js';
+export interface AssetServiceDependencies {
+}
+export interface AssetServiceOptions {
+    assetRepository: IRepositoryPortAsset;
+    serviceDependencies?: Partial<AssetServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class AssetService implements IAssetServicePort {
+    private readonly assetRepository;
+    private readonly logger?;
+    constructor(options: AssetServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmAsset>): Effect.Effect<IbmAsset | null, AssetServiceError>;
+    create(data: IbmAssetInsert): Effect.Effect<IbmAsset, AssetServiceError>;
+    listAssets(filter?: Partial<IbmAsset>, options?: DbQueryOptions<IbmAsset>): Effect.Effect<IbmAsset[], AssetServiceError>;
+    updateAsset(id: string, patch: Partial<IbmAsset>): Effect.Effect<IbmAsset, AssetServiceError>;
+    removeAsset(id: string): Effect.Effect<void, AssetServiceError>;
+}

package/dist/application/services/service.asset.js

@@ -0,0 +1,58 @@
+import { Effect } from 'effect';
+import { pipe } from 'effect/Function';
+import { validateInput, XfErrorFactory, effectErrorInfo } from '@aopslab/xf-core';
+import { mapDbError } from '@aopslab/xf-db';
+import { assetZodSchemaInsert } from '../../domain/models/index.js';
+import { validateBmInputWithSchema } from './service.zod-validation.js';
+export class AssetService {
+    assetRepository;
+    logger;
+    constructor(options) {
+        this.assetRepository = options.assetRepository;
+        this.logger = options.logger?.child({ module: this.constructor.name });
+    }
+    getById(id, options) {
+        const stage = 'AssetService::getById';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((entityId) => this.assetRepository.findById(entityId, options).pipe(Effect.mapError(mapDbError({ stage, operation: 'findById', factory: XfErrorFactory.notFound })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in getById');
+        })));
+    }
+    create(data) {
+        const stage = 'AssetService::create';
+        return pipe(validateInput(data, 'data', { stage }), Effect.flatMap((input) => validateBmInputWithSchema({
+            input,
+            schema: assetZodSchemaInsert,
+            stage,
+            operation: 'AssetService::create.assetZodSchemaInsert',
+            field: 'data',
+        })), Effect.flatMap((input) => this.assetRepository.create(input).pipe(Effect.mapError(mapDbError({ stage, operation: 'create', factory: XfErrorFactory.createFailed })))));
+    }
+    listAssets(filter = {}, options) {
+        const stage = 'AssetService::listAssets';
+        return pipe(validateInput(filter, 'filter', { stage }), Effect.flatMap((matchEq) => this.assetRepository.find({ matchEq, options }).pipe(Effect.mapError(mapDbError({ stage, operation: 'find', factory: XfErrorFactory.notFound })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in listAssets');
+        })));
+    }
+    updateAsset(id, patch) {
+        const stage = 'AssetService::updateAsset';
+        if (!patch || Object.keys(patch).length === 0) {
+            return Effect.fail(XfErrorFactory.inputRequired({ field: 'patch', stage }));
+        }
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((entityId) => validateBmInputWithSchema({
+            input: patch,
+            schema: assetZodSchemaInsert.partial().strict(),
+            stage,
+            operation: 'AssetService::updateAsset.assetZodSchemaInsert.patch',
+            field: 'patch',
+        }).pipe(Effect.map(() => entityId))), Effect.flatMap((entityId) => this.assetRepository.patchById(entityId, patch).pipe(Effect.mapError(mapDbError({ stage, operation: 'patchById', factory: XfErrorFactory.upsertFailed })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in updateAsset');
+        })));
+    }
+    removeAsset(id) {
+        const stage = 'AssetService::removeAsset';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((entityId) => this.assetRepository.deleteById(entityId).pipe(Effect.mapError(mapDbError({ stage, operation: 'deleteById', factory: XfErrorFactory.upsertFailed })))), Effect.map(() => undefined));
+    }
+}