@aopslab/domain-dm-docman 0.1.2

package/dist/application/errors/PageVersionServiceError.js

@@ -0,0 +1,16 @@
+import { Data } from 'effect';
+export var PageVersionErrorCode;
+(function (PageVersionErrorCode) {
+    PageVersionErrorCode["NotFound"] = "NotFound";
+    PageVersionErrorCode["CreateFailed"] = "CreateFailed";
+    PageVersionErrorCode["UpdateFailed"] = "UpdateFailed";
+    PageVersionErrorCode["DeleteFailed"] = "DeleteFailed";
+    //==> domain-specific error codes
+    // CustomError = "CustomError",
+    //<==//
+})(PageVersionErrorCode || (PageVersionErrorCode = {}));
+export const PageVersionErrorTag = {
+    Domain: 'PageVersionDomainError',
+};
+export class PageVersionDomainError extends Data.TaggedError(PageVersionErrorTag.Domain) {
+}

package/dist/application/errors/SectionPageLinkServiceError.d.ts

@@ -0,0 +1,20 @@
+import { XfError, XfUpsertError, WithBaseErrorFields } from '@aopslab/xf-core';
+import { RepositoryError } from '@aopslab/xf-db';
+export declare enum SectionPageLinkErrorCode {
+    NotFound = "NotFound",
+    CreateFailed = "CreateFailed",
+    UpdateFailed = "UpdateFailed",
+    DeleteFailed = "DeleteFailed"
+}
+export declare const SectionPageLinkErrorTag: {
+    readonly Domain: "SectionPageLinkDomainError";
+};
+declare const SectionPageLinkDomainError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SectionPageLinkDomainError";
+} & Readonly<A>;
+export declare class SectionPageLinkDomainError extends SectionPageLinkDomainError_base<WithBaseErrorFields<{
+    id?: string;
+}>> {
+}
+export type SectionPageLinkServiceError = SectionPageLinkDomainError | XfError | RepositoryError | XfUpsertError;
+export {};

package/dist/application/errors/SectionPageLinkServiceError.js

@@ -0,0 +1,16 @@
+import { Data } from 'effect';
+export var SectionPageLinkErrorCode;
+(function (SectionPageLinkErrorCode) {
+    SectionPageLinkErrorCode["NotFound"] = "NotFound";
+    SectionPageLinkErrorCode["CreateFailed"] = "CreateFailed";
+    SectionPageLinkErrorCode["UpdateFailed"] = "UpdateFailed";
+    SectionPageLinkErrorCode["DeleteFailed"] = "DeleteFailed";
+    //==> domain-specific error codes
+    // CustomError = "CustomError",
+    //<==//
+})(SectionPageLinkErrorCode || (SectionPageLinkErrorCode = {}));
+export const SectionPageLinkErrorTag = {
+    Domain: 'SectionPageLinkDomainError',
+};
+export class SectionPageLinkDomainError extends Data.TaggedError(SectionPageLinkErrorTag.Domain) {
+}

package/dist/application/errors/SectionServiceError.d.ts

@@ -0,0 +1,20 @@
+import { XfError, XfUpsertError, WithBaseErrorFields } from '@aopslab/xf-core';
+import { RepositoryError } from '@aopslab/xf-db';
+export declare enum SectionErrorCode {
+    NotFound = "NotFound",
+    CreateFailed = "CreateFailed",
+    UpdateFailed = "UpdateFailed",
+    DeleteFailed = "DeleteFailed"
+}
+export declare const SectionErrorTag: {
+    readonly Domain: "SectionDomainError";
+};
+declare const SectionDomainError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SectionDomainError";
+} & Readonly<A>;
+export declare class SectionDomainError extends SectionDomainError_base<WithBaseErrorFields<{
+    id?: string;
+}>> {
+}
+export type SectionServiceError = SectionDomainError | XfError | RepositoryError | XfUpsertError;
+export {};

package/dist/application/errors/SectionServiceError.js

@@ -0,0 +1,16 @@
+import { Data } from 'effect';
+export var SectionErrorCode;
+(function (SectionErrorCode) {
+    SectionErrorCode["NotFound"] = "NotFound";
+    SectionErrorCode["CreateFailed"] = "CreateFailed";
+    SectionErrorCode["UpdateFailed"] = "UpdateFailed";
+    SectionErrorCode["DeleteFailed"] = "DeleteFailed";
+    //==> domain-specific error codes
+    // CustomError = "CustomError",
+    //<==//
+})(SectionErrorCode || (SectionErrorCode = {}));
+export const SectionErrorTag = {
+    Domain: 'SectionDomainError',
+};
+export class SectionDomainError extends Data.TaggedError(SectionErrorTag.Domain) {
+}

package/dist/application/errors/SnippetServiceError.d.ts

@@ -0,0 +1,20 @@
+import { XfError, XfUpsertError, WithBaseErrorFields } from '@aopslab/xf-core';
+import { RepositoryError } from '@aopslab/xf-db';
+export declare enum SnippetErrorCode {
+    NotFound = "NotFound",
+    CreateFailed = "CreateFailed",
+    UpdateFailed = "UpdateFailed",
+    DeleteFailed = "DeleteFailed"
+}
+export declare const SnippetErrorTag: {
+    readonly Domain: "SnippetDomainError";
+};
+declare const SnippetDomainError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SnippetDomainError";
+} & Readonly<A>;
+export declare class SnippetDomainError extends SnippetDomainError_base<WithBaseErrorFields<{
+    id?: string;
+}>> {
+}
+export type SnippetServiceError = SnippetDomainError | XfError | RepositoryError | XfUpsertError;
+export {};

package/dist/application/errors/SnippetServiceError.js

@@ -0,0 +1,16 @@
+import { Data } from 'effect';
+export var SnippetErrorCode;
+(function (SnippetErrorCode) {
+    SnippetErrorCode["NotFound"] = "NotFound";
+    SnippetErrorCode["CreateFailed"] = "CreateFailed";
+    SnippetErrorCode["UpdateFailed"] = "UpdateFailed";
+    SnippetErrorCode["DeleteFailed"] = "DeleteFailed";
+    //==> domain-specific error codes
+    // CustomError = "CustomError",
+    //<==//
+})(SnippetErrorCode || (SnippetErrorCode = {}));
+export const SnippetErrorTag = {
+    Domain: 'SnippetDomainError',
+};
+export class SnippetDomainError extends Data.TaggedError(SnippetErrorTag.Domain) {
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/application/errors/index.js

@@ -0,0 +1 @@
+export {};

package/dist/application/factories/RepositoryFactoryAsset.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortAsset } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryAsset: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortAsset, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortAsset, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryAsset.js

@@ -0,0 +1,7 @@
+import { AssetDrizzleRepo, AssetDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryAsset = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryAsset',
+    pgRepo: AssetDrizzleRepo,
+    sqliteRepo: AssetDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryAssetVersion.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortAssetVersion } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryAssetVersion: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortAssetVersion, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortAssetVersion, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryAssetVersion.js

@@ -0,0 +1,7 @@
+import { AssetVersionDrizzleRepo, AssetVersionDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryAssetVersion = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryAssetVersion',
+    pgRepo: AssetVersionDrizzleRepo,
+    sqliteRepo: AssetVersionDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryDocument.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortDocument } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryDocument: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortDocument, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortDocument, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryDocument.js

@@ -0,0 +1,7 @@
+import { DocumentDrizzleRepo, DocumentDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryDocument = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryDocument',
+    pgRepo: DocumentDrizzleRepo,
+    sqliteRepo: DocumentDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryDocumentGroup.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortDocumentGroup } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryDocumentGroup: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortDocumentGroup, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortDocumentGroup, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryDocumentGroup.js

@@ -0,0 +1,7 @@
+import { DocumentGroupDrizzleRepo, DocumentGroupDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryDocumentGroup = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryDocumentGroup',
+    pgRepo: DocumentGroupDrizzleRepo,
+    sqliteRepo: DocumentGroupDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryDocumentIndexEntry.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortDocumentIndexEntry } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryDocumentIndexEntry: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortDocumentIndexEntry, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortDocumentIndexEntry, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryDocumentIndexEntry.js

@@ -0,0 +1,7 @@
+import { DocumentIndexEntryDrizzleRepo, DocumentIndexEntryDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryDocumentIndexEntry = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryDocumentIndexEntry',
+    pgRepo: DocumentIndexEntryDrizzleRepo,
+    sqliteRepo: DocumentIndexEntryDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryDocumentSectionLink.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortDocumentSectionLink } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryDocumentSectionLink: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortDocumentSectionLink, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortDocumentSectionLink, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryDocumentSectionLink.js

@@ -0,0 +1,7 @@
+import { DocumentSectionLinkDrizzleRepo, DocumentSectionLinkDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryDocumentSectionLink = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryDocumentSectionLink',
+    pgRepo: DocumentSectionLinkDrizzleRepo,
+    sqliteRepo: DocumentSectionLinkDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryDocumentVersion.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortDocumentVersion } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryDocumentVersion: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortDocumentVersion, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortDocumentVersion, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryDocumentVersion.js

@@ -0,0 +1,7 @@
+import { DocumentVersionDrizzleRepo, DocumentVersionDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryDocumentVersion = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryDocumentVersion',
+    pgRepo: DocumentVersionDrizzleRepo,
+    sqliteRepo: DocumentVersionDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryEmbed.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortEmbed } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryEmbed: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortEmbed, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortEmbed, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryEmbed.js

@@ -0,0 +1,7 @@
+import { EmbedDrizzleRepo, EmbedDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryEmbed = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryEmbed',
+    pgRepo: EmbedDrizzleRepo,
+    sqliteRepo: EmbedDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryPage.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortPage } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryPage: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortPage, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortPage, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryPage.js

@@ -0,0 +1,7 @@
+import { PageDrizzleRepo, PageDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryPage = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryPage',
+    pgRepo: PageDrizzleRepo,
+    sqliteRepo: PageDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryPageEmbedLink.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortPageEmbedLink } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryPageEmbedLink: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortPageEmbedLink, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortPageEmbedLink, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryPageEmbedLink.js

@@ -0,0 +1,7 @@
+import { PageEmbedLinkDrizzleRepo, PageEmbedLinkDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryPageEmbedLink = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryPageEmbedLink',
+    pgRepo: PageEmbedLinkDrizzleRepo,
+    sqliteRepo: PageEmbedLinkDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryPageSnippetLink.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortPageSnippetLink } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryPageSnippetLink: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortPageSnippetLink, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortPageSnippetLink, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryPageSnippetLink.js

@@ -0,0 +1,7 @@
+import { PageSnippetLinkDrizzleRepo, PageSnippetLinkDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryPageSnippetLink = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryPageSnippetLink',
+    pgRepo: PageSnippetLinkDrizzleRepo,
+    sqliteRepo: PageSnippetLinkDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactoryPageVersion.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortPageVersion } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactoryPageVersion: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortPageVersion, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortPageVersion, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactoryPageVersion.js

@@ -0,0 +1,7 @@
+import { PageVersionDrizzleRepo, PageVersionDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactoryPageVersion = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactoryPageVersion',
+    pgRepo: PageVersionDrizzleRepo,
+    sqliteRepo: PageVersionDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactorySection.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortSection } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactorySection: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortSection, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortSection, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactorySection.js

@@ -0,0 +1,7 @@
+import { SectionDrizzleRepo, SectionDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactorySection = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactorySection',
+    pgRepo: SectionDrizzleRepo,
+    sqliteRepo: SectionDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactorySectionPageLink.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortSectionPageLink } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactorySectionPageLink: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortSectionPageLink, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortSectionPageLink, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactorySectionPageLink.js

@@ -0,0 +1,7 @@
+import { SectionPageLinkDrizzleRepo, SectionPageLinkDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactorySectionPageLink = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactorySectionPageLink',
+    pgRepo: SectionPageLinkDrizzleRepo,
+    sqliteRepo: SectionPageLinkDrizzleSqliteRepo,
+});

package/dist/application/factories/RepositoryFactorySnippet.d.ts

@@ -0,0 +1,4 @@
+import { IRepositoryPortSnippet } from '../ports/repository-ports/index.js';
+export declare const RepositoryFactorySnippet: {
+    create(createParams: Parameters<({ repositoryConfig, redisConfig, logger: parentLogger, initConnectionOnCreate, logLevel }: import("@aopslab/xf-dm").RepositoryCreateParams) => import("effect/Effect").Effect<IRepositoryPortSnippet, import("@aopslab/xf-dm").RepositoryFactoryError, never>>[0]): import("effect/Effect").Effect<IRepositoryPortSnippet, import("@aopslab/xf-dm").RepositoryFactoryError, never>;
+};

package/dist/application/factories/RepositoryFactorySnippet.js

@@ -0,0 +1,7 @@
+import { SnippetDrizzleRepo, SnippetDrizzleSqliteRepo } from '../../infrastructure/repositories/index.js';
+import { createDocmanDrizzleRepositoryFactory } from './drizzleDialect.js';
+export const RepositoryFactorySnippet = createDocmanDrizzleRepositoryFactory({
+    moduleName: 'RepositoryFactorySnippet',
+    pgRepo: SnippetDrizzleRepo,
+    sqliteRepo: SnippetDrizzleSqliteRepo,
+});

package/dist/application/factories/ServiceAssetBuilder.d.ts

@@ -0,0 +1,30 @@
+import { Effect } from 'effect';
+import { LocaleOptions } from '@aopslab/xf-dm';
+import { XfLogger } from '@aopslab/xf-logger';
+import { RedisConfig } from '@aopslab/xf-db-redis';
+import { RepositoryConfig } from '@aopslab/xf-db';
+import type { IAssetServicePort } from '../ports/inbound/index.js';
+import type { IRepositoryPortAsset } from '../ports/repository-ports/index.js';
+import { AssetServiceError } from '../errors/AssetServiceError.js';
+export interface AssetServiceFactoryConfig {
+    repositoryConfig?: RepositoryConfig;
+    redisConfig?: RedisConfig;
+    options?: LocaleOptions;
+    logger?: XfLogger;
+    logLevel?: string;
+}
+export interface AssetServiceFactoryOverrides {
+    assetRepository?: IRepositoryPortAsset;
+}
+export declare class ServiceBuilderAsset {
+    private config?;
+    private overrides;
+    private logLevel?;
+    static create(): ServiceBuilderAsset;
+    withConfig(config: AssetServiceFactoryConfig): this;
+    withRepository(repository: IRepositoryPortAsset): this;
+    withLogger(logger?: XfLogger): this;
+    withLogLevel(logLevel?: string): this;
+    withOverrides(overrides: AssetServiceFactoryOverrides): this;
+    build(): Effect.Effect<IAssetServicePort, AssetServiceError>;
+}

package/dist/application/factories/ServiceAssetBuilder.js

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-this-alias */
+import { Effect } from 'effect';
+import { XfConfigurationError } from '@aopslab/xf-core';
+import { getParent } from '@aopslab/xf-logger';
+import { AssetService } from '../services/index.js';
+import { RepositoryFactoryAsset } from './RepositoryFactoryAsset.js';
+export class ServiceBuilderAsset {
+    config;
+    overrides = {};
+    logLevel;
+    static create() {
+        return new ServiceBuilderAsset();
+    }
+    withConfig(config) {
+        this.config = config;
+        return this;
+    }
+    withRepository(repository) {
+        this.overrides.assetRepository = repository;
+        return this;
+    }
+    withLogger(logger) {
+        if (this.config) {
+            this.config.logger = logger;
+        }
+        return this;
+    }
+    withLogLevel(logLevel) {
+        this.logLevel = logLevel;
+        return this;
+    }
+    withOverrides(overrides) {
+        this.overrides = { ...this.overrides, ...overrides };
+        return this;
+    }
+    build() {
+        const self = this;
+        return Effect.gen(function* (_) {
+            if (!self.config && !self.overrides.assetRepository) {
+                return yield* _(Effect.fail(new XfConfigurationError({
+                    message: 'repository override veya repositoryConfig sağlamanız gerekiyor',
+                    operation: 'build',
+                    stage: 'ServiceBuilderAsset::build',
+                })));
+            }
+            const config = self.config ?? {};
+            const effectiveLogLevel = self.logLevel ?? config.logLevel ?? 'info';
+            const logger = config.logger?.child({ module: 'ServiceBuilderAsset', parent: getParent(config.logger) }, { level: effectiveLogLevel });
+            let assetRepository;
+            if (self.overrides.assetRepository) {
+                assetRepository = self.overrides.assetRepository;
+            }
+            else {
+                if (!config.repositoryConfig) {
+                    return yield* _(Effect.fail(new XfConfigurationError({
+                        message: 'Repository konfigürasyonu gerekli. withConfig() sonrası repositoryConfig ayarlayın.',
+                        stage: 'ServiceBuilderAsset::build',
+                    })));
+                }
+                const repositoryParams = {
+                    repositoryConfig: config.repositoryConfig,
+                    redisConfig: config.redisConfig,
+                    logger,
+                };
+                assetRepository = yield* _(Effect.mapError(RepositoryFactoryAsset.create(repositoryParams), (error) => new XfConfigurationError({
+                    message: `RepositoryFactoryAsset.create başarısız: ${error?.message ?? 'unknown'}`,
+                    stage: 'ServiceBuilderAsset::build',
+                    cause: error,
+                })));
+            }
+            const serviceOptions = {
+                assetRepository,
+                logger,
+            };
+            const service = new AssetService(serviceOptions);
+            yield* _(Effect.sync(() => logger?.debug(`Service created: ${service.constructor.name}`)));
+            return service;
+        });
+    }
+}

package/dist/application/factories/ServiceAssetFactory.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from 'effect';
+import type { IAssetServicePort } from '../ports/inbound/index.js';
+import { ServiceBuilderAsset, type AssetServiceFactoryConfig, type AssetServiceFactoryOverrides } from './ServiceAssetBuilder.js';
+import { AssetServiceError } from '../errors/AssetServiceError.js';
+export declare const ServiceFactoryAsset: {
+    create({ config, overrides }: {
+        config: AssetServiceFactoryConfig;
+        overrides?: AssetServiceFactoryOverrides;
+    }): Effect.Effect<IAssetServicePort, AssetServiceError>;
+    builder(): ServiceBuilderAsset;
+};

package/dist/application/factories/ServiceAssetFactory.js

@@ -0,0 +1,15 @@
+import { Effect } from 'effect';
+import { getParent } from '@aopslab/xf-logger';
+import { ServiceBuilderAsset } from './ServiceAssetBuilder.js';
+export const ServiceFactoryAsset = {
+    create({ config, overrides = {} }) {
+        config.logger?.child({ module: 'ServiceFactoryAsset', parent: getParent(config.logger) }, { level: config.logLevel ?? 'info' });
+        return Effect.gen(function* (_) {
+            const builder = ServiceBuilderAsset.create().withConfig(config).withOverrides(overrides);
+            return yield* _(builder.build());
+        });
+    },
+    builder() {
+        return ServiceBuilderAsset.create();
+    },
+};

package/dist/application/factories/ServiceAssetVersionBuilder.d.ts

@@ -0,0 +1,30 @@
+import { Effect } from 'effect';
+import { LocaleOptions } from '@aopslab/xf-dm';
+import { XfLogger } from '@aopslab/xf-logger';
+import { RedisConfig } from '@aopslab/xf-db-redis';
+import { RepositoryConfig } from '@aopslab/xf-db';
+import type { IAssetVersionServicePort } from '../ports/inbound/index.js';
+import type { IRepositoryPortAssetVersion } from '../ports/repository-ports/index.js';
+import { AssetVersionServiceError } from '../errors/AssetVersionServiceError.js';
+export interface AssetVersionServiceFactoryConfig {
+    repositoryConfig?: RepositoryConfig;
+    redisConfig?: RedisConfig;
+    options?: LocaleOptions;
+    logger?: XfLogger;
+    logLevel?: string;
+}
+export interface AssetVersionServiceFactoryOverrides {
+    assetVersionRepository?: IRepositoryPortAssetVersion;
+}
+export declare class ServiceBuilderAssetVersion {
+    private config?;
+    private overrides;
+    private logLevel?;
+    static create(): ServiceBuilderAssetVersion;
+    withConfig(config: AssetVersionServiceFactoryConfig): this;
+    withRepository(repository: IRepositoryPortAssetVersion): this;
+    withLogger(logger?: XfLogger): this;
+    withLogLevel(logLevel?: string): this;
+    withOverrides(overrides: AssetVersionServiceFactoryOverrides): this;
+    build(): Effect.Effect<IAssetVersionServicePort, AssetVersionServiceError>;
+}