@aopslab/domain-dm-docman 0.1.2

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

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortDocumentGroup } from '../ports/repository-ports/index.js';
+import type { IDocumentGroupServicePort } from '../ports/inbound/index.js';
+import { DocumentGroupServiceError } from '../errors/DocumentGroupServiceError.js';
+import { IbmDocumentGroup, IbmDocumentGroupInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+export interface DocumentGroupServiceDependencies {
+}
+export interface DocumentGroupServiceOptions {
+    documentGroupRepository: IRepositoryPortDocumentGroup;
+    serviceDependencies?: Partial<DocumentGroupServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class DocumentGroupService implements IDocumentGroupServicePort {
+    private readonly documentGroupRepository;
+    private readonly logger?;
+    constructor(options: DocumentGroupServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmDocumentGroup>): Effect.Effect<IbmDocumentGroup | null, DocumentGroupServiceError>;
+    create(data: IbmDocumentGroupInsert): Effect.Effect<IbmDocumentGroup, DocumentGroupServiceError>;
+    listDocumentGroups(filter?: Partial<IbmDocumentGroup>, options?: DbQueryOptions<IbmDocumentGroup>): Effect.Effect<IbmDocumentGroup[], DocumentGroupServiceError>;
+    updateDocumentGroup(id: string, patch: Partial<IbmDocumentGroup>): Effect.Effect<IbmDocumentGroup, DocumentGroupServiceError>;
+    removeDocumentGroup(id: string): Effect.Effect<void, DocumentGroupServiceError>;
+}

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

@@ -0,0 +1,58 @@
+import { Effect } from 'effect';
+import { pipe } from 'effect/Function';
+import { validateInput, XfErrorFactory, effectErrorInfo } from '@aopslab/xf-core';
+import { documentGroupZodSchemaInsert } from '../../domain/models/index.js';
+import { validateBmInputWithSchema } from './service.zod-validation.js';
+import { mapDbError } from '@aopslab/xf-db';
+export class DocumentGroupService {
+    documentGroupRepository;
+    logger;
+    constructor(options) {
+        this.documentGroupRepository = options.documentGroupRepository;
+        this.logger = options.logger?.child({ module: this.constructor.name });
+    }
+    getById(id, options) {
+        const stage = 'DocumentGroupService::getById';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((id) => this.documentGroupRepository.findById(id, 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 = 'DocumentGroupService::create';
+        return pipe(validateInput(data, 'data', { stage }), Effect.flatMap((data) => validateBmInputWithSchema({
+            input: data,
+            schema: documentGroupZodSchemaInsert,
+            stage,
+            operation: 'DocumentGroupService::create.documentGroupZodSchemaInsert',
+            field: 'data',
+        })), Effect.flatMap((data) => this.documentGroupRepository.create(data).pipe(Effect.mapError(mapDbError({ stage, operation: 'create', factory: XfErrorFactory.createFailed })))));
+    }
+    listDocumentGroups(filter = {}, options) {
+        const stage = 'DocumentGroupService::listDocumentGroups';
+        return pipe(validateInput(filter, 'filter', { stage }), Effect.flatMap((filter) => this.documentGroupRepository.find({ matchEq: filter, 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 listDocumentGroups');
+        })));
+    }
+    updateDocumentGroup(id, patch) {
+        const stage = 'DocumentGroupService::updateDocumentGroup';
+        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: documentGroupZodSchemaInsert.partial().strict(),
+            stage,
+            operation: 'DocumentGroupService::updateDocumentGroup.documentGroupZodSchemaInsert.patch',
+            field: 'patch',
+        }).pipe(Effect.map(() => entityId))), Effect.flatMap((entityId) => this.documentGroupRepository.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 updateDocumentGroup');
+        })));
+    }
+    removeDocumentGroup(id) {
+        const stage = 'DocumentGroupService::removeDocumentGroup';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((entityId) => this.documentGroupRepository.deleteById(entityId).pipe(Effect.mapError(mapDbError({ stage, operation: 'deleteById', factory: XfErrorFactory.upsertFailed })))), Effect.map(() => undefined));
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortDocumentSectionLink } from '../ports/repository-ports/index.js';
+import type { IDocumentSectionLinkServicePort } from '../ports/inbound/index.js';
+import { DocumentSectionLinkServiceError } from '../errors/DocumentSectionLinkServiceError.js';
+import { IbmDocumentSectionLink, IbmDocumentSectionLinkInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+import type { DocumentSectionLinkUsageItem } from '../ports/repository-ports/IRepositoryPortDocumentSectionLink.js';
+export interface DocumentSectionLinkServiceDependencies {
+}
+export interface DocumentSectionLinkServiceOptions {
+    documentSectionLinkRepository: IRepositoryPortDocumentSectionLink;
+    serviceDependencies?: Partial<DocumentSectionLinkServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class DocumentSectionLinkService implements IDocumentSectionLinkServicePort {
+    private readonly documentSectionLinkRepository;
+    private readonly logger?;
+    constructor(options: DocumentSectionLinkServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmDocumentSectionLink>): Effect.Effect<IbmDocumentSectionLink | null, DocumentSectionLinkServiceError>;
+    create(data: IbmDocumentSectionLinkInsert): Effect.Effect<IbmDocumentSectionLink, DocumentSectionLinkServiceError>;
+    listDocumentSectionLinks(filter?: Partial<IbmDocumentSectionLink>, options?: DbQueryOptions<IbmDocumentSectionLink>): Effect.Effect<IbmDocumentSectionLink[], DocumentSectionLinkServiceError>;
+    updateDocumentSectionLink(id: string, patch: Partial<IbmDocumentSectionLink>): Effect.Effect<IbmDocumentSectionLink, DocumentSectionLinkServiceError>;
+    removeDocumentSectionLink(id: string): Effect.Effect<void, DocumentSectionLinkServiceError>;
+    listDocumentSectionLinkUsageBySectionId(sectionId: string): Effect.Effect<DocumentSectionLinkUsageItem[], DocumentSectionLinkServiceError>;
+}

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

@@ -0,0 +1,69 @@
+import { Effect } from 'effect';
+import { pipe } from 'effect/Function';
+import { validateInput, XfErrorFactory, effectErrorInfo } from '@aopslab/xf-core';
+import { documentSectionLinkZodSchemaInsert, documentSectionLinkZodSchemaPatch, } from '../../domain/models/index.js';
+import { validateBmInputWithSchema } from './service.zod-validation.js';
+import { mapDbError } from '@aopslab/xf-db';
+export class DocumentSectionLinkService {
+    documentSectionLinkRepository;
+    logger;
+    constructor(options) {
+        this.documentSectionLinkRepository = options.documentSectionLinkRepository;
+        this.logger = options.logger?.child({ module: this.constructor.name });
+    }
+    getById(id, options) {
+        const stage = 'DocumentSectionLinkService::getById';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((id) => this.documentSectionLinkRepository.findById(id, 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 = 'DocumentSectionLinkService::create';
+        return pipe(validateInput(data, 'data', { stage }), Effect.flatMap((data) => validateBmInputWithSchema({
+            input: data,
+            schema: documentSectionLinkZodSchemaInsert,
+            stage,
+            operation: 'DocumentSectionLinkService::create.documentSectionLinkZodSchemaInsert',
+            field: 'data',
+        })), Effect.flatMap((data) => this.documentSectionLinkRepository.create(data).pipe(Effect.mapError(mapDbError({ stage, operation: 'create', factory: XfErrorFactory.createFailed })))));
+    }
+    listDocumentSectionLinks(filter = {}, options) {
+        const stage = 'DocumentSectionLinkService::listDocumentSectionLinks';
+        return pipe(validateInput(filter, 'filter', { stage }), Effect.flatMap((filter) => this.documentSectionLinkRepository.find({ matchEq: filter, 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 listDocumentSectionLinks');
+        })));
+    }
+    updateDocumentSectionLink(id, patch) {
+        const stage = 'DocumentSectionLinkService::updateDocumentSectionLink';
+        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: documentSectionLinkZodSchemaPatch,
+            stage,
+            operation: 'DocumentSectionLinkService::updateDocumentSectionLink.documentSectionLinkZodSchemaInsert.patch',
+            field: 'patch',
+        }).pipe(Effect.map(() => entityId))), Effect.flatMap((entityId) => this.documentSectionLinkRepository.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 updateDocumentSectionLink');
+        })));
+    }
+    removeDocumentSectionLink(id) {
+        const stage = 'DocumentSectionLinkService::removeDocumentSectionLink';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((entityId) => this.documentSectionLinkRepository.deleteById(entityId).pipe(Effect.mapError(mapDbError({ stage, operation: 'deleteById', factory: XfErrorFactory.upsertFailed })))), Effect.map(() => undefined));
+    }
+    listDocumentSectionLinkUsageBySectionId(sectionId) {
+        const stage = 'DocumentSectionLinkService::listDocumentSectionLinkUsageBySectionId';
+        return pipe(validateInput(sectionId, 'sectionId', { stage }), Effect.flatMap((id) => this.documentSectionLinkRepository.listDocumentSectionLinkUsageBySectionId(id).pipe(Effect.mapError(mapDbError({
+            stage,
+            operation: 'listDocumentSectionLinkUsageBySectionId',
+            factory: XfErrorFactory.notFound,
+        })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in listDocumentSectionLinkUsageBySectionId');
+        })));
+    }
+}

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

@@ -0,0 +1,66 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortDocument, IRepositoryPortDocumentSectionLink, IRepositoryPortDocumentVersion, IRepositoryPortPage, IRepositoryPortPageEmbedLink, IRepositoryPortPageSnippetLink, IRepositoryPortPageVersion, IRepositoryPortSection, IRepositoryPortSectionPageLink } from '../ports/repository-ports/index.js';
+import type { DocmanDocumentVersionImportHeadingsInput, DocmanDocumentVersionImportHeadingsResult, DocmanDocumentVersionSetCurrentInput, DocmanDocumentVersionSetCurrentResult, IDocumentVersionServicePort } from '../ports/inbound/index.js';
+import { DocumentVersionServiceError } from '../errors/DocumentVersionServiceError.js';
+import { IbmDocumentVersion, IbmDocumentVersionInsert } from '../../domain/models/index.js';
+import { DbQueryOptions, IUnitOfWork } from '@aopslab/xf-db';
+import { type DocmanDocumentVersionDeleteReport } from './documentCascadeDelete.js';
+export interface DocumentVersionServiceDependencies {
+    documentRepository?: IRepositoryPortDocument;
+    documentSectionLinkRepository?: IRepositoryPortDocumentSectionLink;
+    sectionRepository?: IRepositoryPortSection;
+    pageRepository?: IRepositoryPortPage;
+    pageVersionRepository?: IRepositoryPortPageVersion;
+    sectionPageLinkRepository?: IRepositoryPortSectionPageLink;
+    pageSnippetLinkRepository?: IRepositoryPortPageSnippetLink;
+    pageEmbedLinkRepository?: IRepositoryPortPageEmbedLink;
+}
+export interface DocumentVersionServiceOptions {
+    documentVersionRepository: IRepositoryPortDocumentVersion;
+    serviceDependencies?: Partial<DocumentVersionServiceDependencies>;
+    unitOfWork?: IUnitOfWork;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class DocumentVersionService implements IDocumentVersionServicePort {
+    private readonly documentVersionRepository;
+    private readonly documentRepository?;
+    private readonly documentSectionLinkRepository?;
+    private readonly sectionRepository?;
+    private readonly pageRepository?;
+    private readonly pageVersionRepository?;
+    private readonly sectionPageLinkRepository?;
+    private readonly pageSnippetLinkRepository?;
+    private readonly pageEmbedLinkRepository?;
+    private readonly unitOfWork?;
+    private readonly logger?;
+    private readonly locale?;
+    constructor(options: DocumentVersionServiceOptions);
+    private bindRepositoryContext;
+    private withRepositoryContext;
+    private runHeadingImportWriteEffect;
+    getById(id: string, options?: DbQueryOptions<IbmDocumentVersion>): Effect.Effect<IbmDocumentVersion | null, DocumentVersionServiceError>;
+    create(data: IbmDocumentVersionInsert): Effect.Effect<IbmDocumentVersion, DocumentVersionServiceError>;
+    listDocumentVersions(filter?: Partial<IbmDocumentVersion>, options?: DbQueryOptions<IbmDocumentVersion>): Effect.Effect<IbmDocumentVersion[], DocumentVersionServiceError>;
+    updateDocumentVersion(id: string, patch: Partial<IbmDocumentVersion>): Effect.Effect<IbmDocumentVersion, DocumentVersionServiceError>;
+    setCurrent(input: DocmanDocumentVersionSetCurrentInput): Effect.Effect<DocmanDocumentVersionSetCurrentResult, DocumentVersionServiceError>;
+    removeDocumentVersion(id: string): Effect.Effect<void, DocumentVersionServiceError>;
+    removeDocumentVersionSafe(id: string): Effect.Effect<DocmanDocumentVersionDeleteReport, DocumentVersionServiceError>;
+    importHeadings(input: DocmanDocumentVersionImportHeadingsInput): Effect.Effect<DocmanDocumentVersionImportHeadingsResult, DocumentVersionServiceError>;
+    private validateHeadingImportInput;
+    private resolveHeadingImportDependencies;
+    private buildHeadingImportPlan;
+    private buildHeadingImportResult;
+    private deleteExistingDocumentVersionLinksForHeadingImport;
+    private buildHeadingImportUid;
+    private buildHeadingImportSlug;
+    private slugifyForImport;
+    private ensureTrailingNewline;
+    private normalizeNonEmpty;
+    private resolveCascadeDependencies;
+    private requireDependency;
+    private normalizeCascadeError;
+    private ensureVersionIsUniqueForDocument;
+    private withLocaleOptions;
+}