@aopslab/domain-dm-docman 0.1.2

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

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortEmbed } from '../ports/repository-ports/index.js';
+import type { IEmbedServicePort } from '../ports/inbound/index.js';
+import { EmbedServiceError } from '../errors/EmbedServiceError.js';
+import { IbmEmbed, IbmEmbedInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+export interface EmbedServiceDependencies {
+}
+export interface EmbedServiceOptions {
+    embedRepository: IRepositoryPortEmbed;
+    serviceDependencies?: Partial<EmbedServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class EmbedService implements IEmbedServicePort {
+    private readonly embedRepository;
+    private readonly logger?;
+    constructor(options: EmbedServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmEmbed>): Effect.Effect<IbmEmbed | null, EmbedServiceError>;
+    create(data: IbmEmbedInsert): Effect.Effect<IbmEmbed, EmbedServiceError>;
+    listEmbeds(filter?: Partial<IbmEmbed>, options?: DbQueryOptions<IbmEmbed>): Effect.Effect<IbmEmbed[], EmbedServiceError>;
+    updateEmbed(id: string, patch: Partial<IbmEmbed>): Effect.Effect<IbmEmbed, EmbedServiceError>;
+    removeEmbed(id: string): Effect.Effect<void, EmbedServiceError>;
+}

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

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

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

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortPage } from '../ports/repository-ports/index.js';
+import type { IPageServicePort } from '../ports/inbound/index.js';
+import { PageServiceError } from '../errors/PageServiceError.js';
+import { IbmPage, IbmPageInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+export interface PageServiceDependencies {
+}
+export interface PageServiceOptions {
+    pageRepository: IRepositoryPortPage;
+    serviceDependencies?: Partial<PageServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class PageService implements IPageServicePort {
+    private readonly pageRepository;
+    private readonly logger?;
+    constructor(options: PageServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmPage>): Effect.Effect<IbmPage | null, PageServiceError>;
+    create(data: IbmPageInsert): Effect.Effect<IbmPage, PageServiceError>;
+    listPages(filter?: Partial<IbmPage>, options?: DbQueryOptions<IbmPage>): Effect.Effect<IbmPage[], PageServiceError>;
+    updatePage(id: string, patch: Partial<IbmPage>): Effect.Effect<IbmPage, PageServiceError>;
+    removePage(id: string): Effect.Effect<void, PageServiceError>;
+}

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

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

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

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortPageEmbedLink } from '../ports/repository-ports/index.js';
+import type { IPageEmbedLinkServicePort } from '../ports/inbound/index.js';
+import { PageEmbedLinkServiceError } from '../errors/PageEmbedLinkServiceError.js';
+import { IbmPageEmbedLink, IbmPageEmbedLinkInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+export interface PageEmbedLinkServiceDependencies {
+}
+export interface PageEmbedLinkServiceOptions {
+    pageEmbedLinkRepository: IRepositoryPortPageEmbedLink;
+    serviceDependencies?: Partial<PageEmbedLinkServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class PageEmbedLinkService implements IPageEmbedLinkServicePort {
+    private readonly pageEmbedLinkRepository;
+    private readonly logger?;
+    constructor(options: PageEmbedLinkServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmPageEmbedLink>): Effect.Effect<IbmPageEmbedLink | null, PageEmbedLinkServiceError>;
+    create(data: IbmPageEmbedLinkInsert): Effect.Effect<IbmPageEmbedLink, PageEmbedLinkServiceError>;
+    listPageEmbedLinks(filter?: Partial<IbmPageEmbedLink>, options?: DbQueryOptions<IbmPageEmbedLink>): Effect.Effect<IbmPageEmbedLink[], PageEmbedLinkServiceError>;
+    updatePageEmbedLink(id: string, patch: Partial<IbmPageEmbedLink>): Effect.Effect<IbmPageEmbedLink, PageEmbedLinkServiceError>;
+    removePageEmbedLink(id: string): Effect.Effect<void, PageEmbedLinkServiceError>;
+}

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

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

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

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortPageSnippetLink } from '../ports/repository-ports/index.js';
+import type { IPageSnippetLinkServicePort } from '../ports/inbound/index.js';
+import { PageSnippetLinkServiceError } from '../errors/PageSnippetLinkServiceError.js';
+import { IbmPageSnippetLink, IbmPageSnippetLinkInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+export interface PageSnippetLinkServiceDependencies {
+}
+export interface PageSnippetLinkServiceOptions {
+    pageSnippetLinkRepository: IRepositoryPortPageSnippetLink;
+    serviceDependencies?: Partial<PageSnippetLinkServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class PageSnippetLinkService implements IPageSnippetLinkServicePort {
+    private readonly pageSnippetLinkRepository;
+    private readonly logger?;
+    constructor(options: PageSnippetLinkServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmPageSnippetLink>): Effect.Effect<IbmPageSnippetLink | null, PageSnippetLinkServiceError>;
+    create(data: IbmPageSnippetLinkInsert): Effect.Effect<IbmPageSnippetLink, PageSnippetLinkServiceError>;
+    listPageSnippetLinks(filter?: Partial<IbmPageSnippetLink>, options?: DbQueryOptions<IbmPageSnippetLink>): Effect.Effect<IbmPageSnippetLink[], PageSnippetLinkServiceError>;
+    updatePageSnippetLink(id: string, patch: Partial<IbmPageSnippetLink>): Effect.Effect<IbmPageSnippetLink, PageSnippetLinkServiceError>;
+    removePageSnippetLink(id: string): Effect.Effect<void, PageSnippetLinkServiceError>;
+}

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

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

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

@@ -0,0 +1,31 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortDocumentSectionLink, IRepositoryPortPageVersion, IRepositoryPortSectionPageLink } from '../ports/repository-ports/index.js';
+import type { IPageVersionServicePort } from '../ports/inbound/index.js';
+import { PageVersionServiceError } from '../errors/PageVersionServiceError.js';
+import { IbmPageVersion, IbmPageVersionInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+export interface PageVersionServiceDependencies {
+    documentSectionLinkRepository?: IRepositoryPortDocumentSectionLink;
+    sectionPageLinkRepository?: IRepositoryPortSectionPageLink;
+}
+export interface PageVersionServiceOptions {
+    pageVersionRepository: IRepositoryPortPageVersion;
+    serviceDependencies?: Partial<PageVersionServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class PageVersionService implements IPageVersionServicePort {
+    private readonly pageVersionRepository;
+    private readonly documentSectionLinkRepository?;
+    private readonly sectionPageLinkRepository?;
+    private readonly logger?;
+    constructor(options: PageVersionServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmPageVersion>): Effect.Effect<IbmPageVersion | null, PageVersionServiceError>;
+    create(data: IbmPageVersionInsert): Effect.Effect<IbmPageVersion, PageVersionServiceError>;
+    listPageVersions(filter?: Partial<IbmPageVersion>, options?: DbQueryOptions<IbmPageVersion>): Effect.Effect<IbmPageVersion[], PageVersionServiceError>;
+    updatePageVersion(id: string, patch: Partial<IbmPageVersion>): Effect.Effect<IbmPageVersion, PageVersionServiceError>;
+    removePageVersion(id: string): Effect.Effect<void, PageVersionServiceError>;
+    private ensurePageVersionIsUnlinked;
+    private requireDependency;
+}

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

@@ -0,0 +1,114 @@
+import { Effect } from 'effect';
+import { pipe } from 'effect/Function';
+import { validateInput, XfErrorFactory, effectErrorInfo } from '@aopslab/xf-core';
+import { pageVersionZodSchemaInsert } from '../../domain/models/index.js';
+import { validateBmInputWithSchema } from './service.zod-validation.js';
+import { mapDbError } from '@aopslab/xf-db';
+export class PageVersionService {
+    pageVersionRepository;
+    documentSectionLinkRepository;
+    sectionPageLinkRepository;
+    logger;
+    constructor(options) {
+        const deps = options.serviceDependencies ?? {};
+        this.pageVersionRepository = options.pageVersionRepository;
+        this.documentSectionLinkRepository = deps.documentSectionLinkRepository;
+        this.sectionPageLinkRepository = deps.sectionPageLinkRepository;
+        this.logger = options.logger?.child({ module: this.constructor.name });
+    }
+    getById(id, options) {
+        const stage = 'PageVersionService::getById';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((id) => this.pageVersionRepository.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 = 'PageVersionService::create';
+        return pipe(validateInput(data, 'data', { stage }), Effect.flatMap((data) => validateBmInputWithSchema({
+            input: data,
+            schema: pageVersionZodSchemaInsert,
+            stage,
+            operation: 'PageVersionService::create.pageVersionZodSchemaInsert',
+            field: 'data',
+        })), Effect.flatMap((data) => this.pageVersionRepository.create(data).pipe(Effect.mapError(mapDbError({ stage, operation: 'create', factory: XfErrorFactory.createFailed })))));
+    }
+    listPageVersions(filter = {}, options) {
+        const stage = 'PageVersionService::listPageVersions';
+        return pipe(validateInput(filter, 'filter', { stage }), Effect.flatMap((filter) => this.pageVersionRepository.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 listPageVersions');
+        })));
+    }
+    updatePageVersion(id, patch) {
+        const stage = 'PageVersionService::updatePageVersion';
+        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: pageVersionZodSchemaInsert.partial().strict(),
+            stage,
+            operation: 'PageVersionService::updatePageVersion.pageVersionZodSchemaInsert.patch',
+            field: 'patch',
+        }).pipe(Effect.map(() => entityId))), Effect.flatMap((entityId) => this.pageVersionRepository.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 updatePageVersion');
+        })));
+    }
+    removePageVersion(id) {
+        const stage = 'PageVersionService::removePageVersion';
+        return Effect.gen(this, function* (_) {
+            const entityId = yield* _(validateInput(id, 'id', { stage }));
+            yield* _(this.ensurePageVersionIsUnlinked(entityId, stage, 'removePageVersion'));
+            yield* _(this.pageVersionRepository.deleteById(entityId).pipe(Effect.mapError(mapDbError({ stage, operation: 'deleteById', factory: XfErrorFactory.upsertFailed }))));
+            return undefined;
+        }).pipe(Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in removePageVersion');
+        })));
+    }
+    ensurePageVersionIsUnlinked(pageVersionId, stage, operation) {
+        return Effect.gen(this, function* (_) {
+            const documentSectionLinkRepository = yield* _(this.requireDependency(this.documentSectionLinkRepository, 'documentSectionLinkRepository', stage, operation));
+            const sectionPageLinkRepository = yield* _(this.requireDependency(this.sectionPageLinkRepository, 'sectionPageLinkRepository', stage, operation));
+            const [documentLinks, sectionLinks] = yield* _(Effect.all([
+                documentSectionLinkRepository.find({ matchEq: { pageVersionId } }).pipe(Effect.mapError(mapDbError({
+                    stage,
+                    operation: 'documentSectionLinkRepository.find(pageVersionId)',
+                    factory: XfErrorFactory.upsertFailed,
+                }))),
+                sectionPageLinkRepository.find({ matchEq: { pageVersionId } }).pipe(Effect.mapError(mapDbError({
+                    stage,
+                    operation: 'sectionPageLinkRepository.find(pageVersionId)',
+                    factory: XfErrorFactory.upsertFailed,
+                }))),
+            ]));
+            const documentLinkCount = Array.isArray(documentLinks) ? documentLinks.length : 0;
+            const sectionLinkCount = Array.isArray(sectionLinks) ? sectionLinks.length : 0;
+            if (documentLinkCount === 0 && sectionLinkCount === 0) {
+                return;
+            }
+            return yield* _(Effect.fail(XfErrorFactory.upsertFailed({
+                stage,
+                operation: 'checkPageVersionUsage',
+                message: 'Page version is still linked in document or section outlines.',
+                data: {
+                    pageVersionId,
+                    documentLinkCount,
+                    sectionLinkCount,
+                },
+            })));
+        });
+    }
+    requireDependency(dependency, name, stage, operation) {
+        if (dependency)
+            return Effect.succeed(dependency);
+        return Effect.fail(XfErrorFactory.configurationError({
+            stage,
+            operation,
+            message: `Missing dependency: ${name}`,
+            debug: { dependency: name },
+        }));
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortSection } from '../ports/repository-ports/index.js';
+import type { ISectionServicePort } from '../ports/inbound/index.js';
+import { SectionServiceError } from '../errors/SectionServiceError.js';
+import { IbmSection, IbmSectionInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+export interface SectionServiceDependencies {
+}
+export interface SectionServiceOptions {
+    sectionRepository: IRepositoryPortSection;
+    serviceDependencies?: Partial<SectionServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class SectionService implements ISectionServicePort {
+    private readonly sectionRepository;
+    private readonly logger?;
+    constructor(options: SectionServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmSection>): Effect.Effect<IbmSection | null, SectionServiceError>;
+    create(data: IbmSectionInsert): Effect.Effect<IbmSection, SectionServiceError>;
+    listSections(filter?: Partial<IbmSection>, options?: DbQueryOptions<IbmSection>): Effect.Effect<IbmSection[], SectionServiceError>;
+    updateSection(id: string, patch: Partial<IbmSection>): Effect.Effect<IbmSection, SectionServiceError>;
+    removeSection(id: string): Effect.Effect<void, SectionServiceError>;
+}

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

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

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

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortSectionPageLink } from '../ports/repository-ports/index.js';
+import type { ISectionPageLinkServicePort } from '../ports/inbound/index.js';
+import { SectionPageLinkServiceError } from '../errors/SectionPageLinkServiceError.js';
+import { IbmSectionPageLink, IbmSectionPageLinkInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+export interface SectionPageLinkServiceDependencies {
+}
+export interface SectionPageLinkServiceOptions {
+    sectionPageLinkRepository: IRepositoryPortSectionPageLink;
+    serviceDependencies?: Partial<SectionPageLinkServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class SectionPageLinkService implements ISectionPageLinkServicePort {
+    private readonly sectionPageLinkRepository;
+    private readonly logger?;
+    constructor(options: SectionPageLinkServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmSectionPageLink>): Effect.Effect<IbmSectionPageLink | null, SectionPageLinkServiceError>;
+    create(data: IbmSectionPageLinkInsert): Effect.Effect<IbmSectionPageLink, SectionPageLinkServiceError>;
+    listSectionPageLinks(filter?: Partial<IbmSectionPageLink>, options?: DbQueryOptions<IbmSectionPageLink>): Effect.Effect<IbmSectionPageLink[], SectionPageLinkServiceError>;
+    updateSectionPageLink(id: string, patch: Partial<IbmSectionPageLink>): Effect.Effect<IbmSectionPageLink, SectionPageLinkServiceError>;
+    removeSectionPageLink(id: string): Effect.Effect<void, SectionPageLinkServiceError>;
+}