ofcoop-credit-shared-core 0.1.0-alpha.0

package/dist/data/repositories.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreditPolicyRepository = exports.InstallmentRepository = exports.LoanRepository = void 0;
+exports.createOfcoopCreditRepositories = createOfcoopCreditRepositories;
+const schemas_1 = require("./schemas");
+function toAnd(filters) {
+    if (filters.length === 0)
+        return undefined;
+    if (filters.length === 1)
+        return filters[0];
+    return { and: filters };
+}
+class LoanRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async create(row) {
+        return this.db.create(schemas_1.OFCOOP_CREDIT_TABLES.loans, row);
+    }
+    async update(id, updates) {
+        return this.db.update(schemas_1.OFCOOP_CREDIT_TABLES.loans, id, updates);
+    }
+    async getById(id) {
+        return this.db.get(schemas_1.OFCOOP_CREDIT_TABLES.loans, id);
+    }
+    async listByMember(memberId, options) {
+        const filters = [{ memberId }];
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        if (options?.status)
+            filters.push({ status: options.status });
+        if (options?.tenantId !== undefined)
+            filters.push({ tenantId: options.tenantId ?? null });
+        if (options?.branchId !== undefined)
+            filters.push({ branchId: options.branchId ?? null });
+        return this.db.query(schemas_1.OFCOOP_CREDIT_TABLES.loans, {
+            filters: toAnd(filters),
+            sort: [{ field: 'lastModified', direction: 'desc' }],
+        });
+    }
+    async list(options) {
+        const filters = [];
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        if (options?.status)
+            filters.push({ status: options.status });
+        if (options?.tenantId !== undefined)
+            filters.push({ tenantId: options.tenantId ?? null });
+        if (options?.branchId !== undefined)
+            filters.push({ branchId: options.branchId ?? null });
+        return this.db.query(schemas_1.OFCOOP_CREDIT_TABLES.loans, {
+            filters: toAnd(filters),
+            sort: [{ field: 'lastModified', direction: 'desc' }],
+        });
+    }
+}
+exports.LoanRepository = LoanRepository;
+class InstallmentRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async createMany(rows) {
+        if (rows.length === 0)
+            return [];
+        return this.db.bulkCreate(schemas_1.OFCOOP_CREDIT_TABLES.installments, rows);
+    }
+    async update(id, updates) {
+        return this.db.update(schemas_1.OFCOOP_CREDIT_TABLES.installments, id, updates);
+    }
+    async listByLoan(loanId, options) {
+        const filters = [{ loanId }];
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        if (options?.status)
+            filters.push({ status: options.status });
+        if (options?.dueDateFrom)
+            filters.push({ field: 'dueDate', operator: '>=', value: options.dueDateFrom });
+        if (options?.dueDateTo)
+            filters.push({ field: 'dueDate', operator: '<=', value: options.dueDateTo });
+        return this.db.query(schemas_1.OFCOOP_CREDIT_TABLES.installments, {
+            filters: toAnd(filters),
+            sort: [{ field: 'installmentNo', direction: 'asc' }],
+        });
+    }
+    async list(options) {
+        const filters = [];
+        if (options?.loanId)
+            filters.push({ loanId: options.loanId });
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        if (options?.status)
+            filters.push({ status: options.status });
+        if (options?.dueDateFrom)
+            filters.push({ field: 'dueDate', operator: '>=', value: options.dueDateFrom });
+        if (options?.dueDateTo)
+            filters.push({ field: 'dueDate', operator: '<=', value: options.dueDateTo });
+        return this.db.query(schemas_1.OFCOOP_CREDIT_TABLES.installments, {
+            filters: toAnd(filters),
+            sort: [{ field: 'dueDate', direction: 'asc' }],
+        });
+    }
+    async getByLoanAndInstallmentNo(loanId, installmentNo) {
+        const rows = await this.db.query(schemas_1.OFCOOP_CREDIT_TABLES.installments, {
+            filters: {
+                and: [
+                    { deleted: false },
+                    { loanId },
+                    { installmentNo },
+                ],
+            },
+            sort: [{ field: 'lastModified', direction: 'desc' }],
+            limit: 1,
+        });
+        return rows[0] ?? null;
+    }
+    async listOverdue(options) {
+        const filters = [{ status: 'overdue' }];
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        if (options?.dueDateFrom)
+            filters.push({ field: 'dueDate', operator: '>=', value: options.dueDateFrom });
+        if (options?.dueDateTo)
+            filters.push({ field: 'dueDate', operator: '<=', value: options.dueDateTo });
+        return this.db.query(schemas_1.OFCOOP_CREDIT_TABLES.installments, {
+            filters: toAnd(filters),
+            sort: [{ field: 'dueDate', direction: 'asc' }],
+        });
+    }
+}
+exports.InstallmentRepository = InstallmentRepository;
+class CreditPolicyRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async create(row) {
+        return this.db.create(schemas_1.OFCOOP_CREDIT_TABLES.creditPolicies, row);
+    }
+    async update(id, updates) {
+        return this.db.update(schemas_1.OFCOOP_CREDIT_TABLES.creditPolicies, id, updates);
+    }
+    async getById(id) {
+        return this.db.get(schemas_1.OFCOOP_CREDIT_TABLES.creditPolicies, id);
+    }
+    async getActive(scope) {
+        const rows = await this.db.query(schemas_1.OFCOOP_CREDIT_TABLES.creditPolicies, {
+            filters: {
+                and: [
+                    { deleted: false },
+                    { isActive: true },
+                    { tenantId: scope.tenantId },
+                    { branchId: scope.branchId ?? null },
+                ],
+            },
+            sort: [{ field: 'lastModified', direction: 'desc' }],
+            limit: 1,
+        });
+        return rows[0] ?? null;
+    }
+}
+exports.CreditPolicyRepository = CreditPolicyRepository;
+function createOfcoopCreditRepositories(db) {
+    return {
+        loanRepository: new LoanRepository(db),
+        installmentRepository: new InstallmentRepository(db),
+        creditPolicyRepository: new CreditPolicyRepository(db),
+    };
+}

package/dist/data/schemas.d.ts

@@ -0,0 +1,8 @@
+import type { DbSchema, TableSchema } from 'ofcore';
+export declare const OFCOOP_CREDIT_TABLES: {
+    readonly loans: "ofcoop_credit_loans";
+    readonly installments: "ofcoop_credit_installments";
+    readonly creditPolicies: "ofcoop_credit_policies";
+};
+export declare const ofcoopCreditSchema: DbSchema;
+export declare function getOfcoopCreditTableSchemas(): TableSchema[];

package/dist/data/schemas.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ofcoopCreditSchema = exports.OFCOOP_CREDIT_TABLES = void 0;
+exports.getOfcoopCreditTableSchemas = getOfcoopCreditTableSchemas;
+exports.OFCOOP_CREDIT_TABLES = {
+    loans: 'ofcoop_credit_loans',
+    installments: 'ofcoop_credit_installments',
+    creditPolicies: 'ofcoop_credit_policies',
+};
+const tableSchemas = [
+    {
+        name: exports.OFCOOP_CREDIT_TABLES.loans,
+        columns: [
+            { name: 'id', type: 'string' },
+            { name: 'memberId', type: 'string', isIndexed: true },
+            { name: 'principalAmount', type: 'number' },
+            { name: 'tenorMonths', type: 'number' },
+            { name: 'serviceRate', type: 'number' },
+            { name: 'startDate', type: 'string' },
+            { name: 'status', type: 'string', enum: ['active', 'closed', 'defaulted'], isIndexed: true },
+            { name: 'branchId', type: 'string', isOptional: true, isIndexed: true },
+            { name: 'tenantId', type: 'string', isOptional: true, isIndexed: true },
+            { name: 'version', type: 'number' },
+            { name: 'lastModified', type: 'string' },
+            { name: 'deleted', type: 'boolean', isIndexed: true },
+        ],
+    },
+    {
+        name: exports.OFCOOP_CREDIT_TABLES.installments,
+        columns: [
+            { name: 'id', type: 'string' },
+            { name: 'loanId', type: 'string', isIndexed: true },
+            { name: 'installmentNo', type: 'number' },
+            { name: 'dueDate', type: 'string', isIndexed: true },
+            { name: 'principalDue', type: 'number' },
+            { name: 'serviceDue', type: 'number' },
+            { name: 'penaltyDue', type: 'number' },
+            { name: 'paidAmount', type: 'number' },
+            { name: 'status', type: 'string', enum: ['scheduled', 'partial', 'paid', 'overdue'], isIndexed: true },
+            { name: 'branchId', type: 'string', isOptional: true, isIndexed: true },
+            { name: 'tenantId', type: 'string', isOptional: true, isIndexed: true },
+            { name: 'version', type: 'number' },
+            { name: 'lastModified', type: 'string' },
+            { name: 'deleted', type: 'boolean', isIndexed: true },
+        ],
+    },
+    {
+        name: exports.OFCOOP_CREDIT_TABLES.creditPolicies,
+        columns: [
+            { name: 'id', type: 'string' },
+            { name: 'policyCode', type: 'string', isIndexed: true },
+            { name: 'penaltyRatePerDay', type: 'number' },
+            { name: 'gracePeriodDays', type: 'number' },
+            { name: 'maxTenorMonths', type: 'number' },
+            { name: 'isActive', type: 'boolean', isIndexed: true },
+            { name: 'branchId', type: 'string', isOptional: true, isIndexed: true },
+            { name: 'tenantId', type: 'string', isOptional: true, isIndexed: true },
+            { name: 'version', type: 'number' },
+            { name: 'lastModified', type: 'string' },
+            { name: 'deleted', type: 'boolean', isIndexed: true },
+        ],
+    },
+];
+exports.ofcoopCreditSchema = {
+    version: 1,
+    tables: tableSchemas,
+};
+function getOfcoopCreditTableSchemas() {
+    return exports.ofcoopCreditSchema.tables;
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from './contracts/LoanContract';
+export * from './contracts/InstallmentContract';
+export * from './contracts/CreditPolicyContract';
+export * from './contracts/LoanBoardContract';
+export * from './contracts/LoanDueWindowContract';
+export * from './OfcoopCreditCore';
+export * from './services/LoanService';
+export * from './services/InstallmentService';
+export * from './services/CreditPolicyService';
+export * from './services/LoanBoardService';
+export * from './services/LoanDueWindowService';
+export * from './services/CreditOrchestrationService';
+export * from './services/errors';
+export * from './services/createDbAdapterOfcoopCreditServices';
+export * from './data/schemas';
+export * from './data/migrations';
+export * from './data/applyPendingMigrations';
+export * from './data/repositories';

package/dist/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./contracts/LoanContract"), exports);
+__exportStar(require("./contracts/InstallmentContract"), exports);
+__exportStar(require("./contracts/CreditPolicyContract"), exports);
+__exportStar(require("./contracts/LoanBoardContract"), exports);
+__exportStar(require("./contracts/LoanDueWindowContract"), exports);
+__exportStar(require("./OfcoopCreditCore"), exports);
+__exportStar(require("./services/LoanService"), exports);
+__exportStar(require("./services/InstallmentService"), exports);
+__exportStar(require("./services/CreditPolicyService"), exports);
+__exportStar(require("./services/LoanBoardService"), exports);
+__exportStar(require("./services/LoanDueWindowService"), exports);
+__exportStar(require("./services/CreditOrchestrationService"), exports);
+__exportStar(require("./services/errors"), exports);
+__exportStar(require("./services/createDbAdapterOfcoopCreditServices"), exports);
+__exportStar(require("./data/schemas"), exports);
+__exportStar(require("./data/migrations"), exports);
+__exportStar(require("./data/applyPendingMigrations"), exports);
+__exportStar(require("./data/repositories"), exports);

package/dist/services/CreditOrchestrationService.d.ts

@@ -0,0 +1,32 @@
+import type { InstallmentContract, InstallmentServiceContract, RecordInstallmentPaymentInput } from '../contracts/InstallmentContract';
+import type { CreateLoanInput, LoanContract, LoanServiceContract } from '../contracts/LoanContract';
+import type { LoanBoardItemContract, LoanBoardScope, LoanBoardServiceContract } from '../contracts/LoanBoardContract';
+import type { LoanDueWindowItemContract, LoanDueWindowQueryInput, LoanDueWindowScope, LoanDueWindowServiceContract } from '../contracts/LoanDueWindowContract';
+export interface CreditOrchestrationDependencies {
+    loanService: LoanServiceContract;
+    installmentService: InstallmentServiceContract;
+    loanBoardService: LoanBoardServiceContract;
+    loanDueWindowService: LoanDueWindowServiceContract;
+}
+export interface CreateLoanWithScheduleResult {
+    loan: LoanContract;
+    installments: InstallmentContract[];
+}
+export declare function createLoanWithSchedule(deps: Pick<CreditOrchestrationDependencies, 'loanService' | 'installmentService'>, input: CreateLoanInput): Promise<CreateLoanWithScheduleResult>;
+export interface RecordPaymentAndBoardResult {
+    installment: InstallmentContract;
+    board: LoanBoardItemContract[];
+}
+export declare function recordPaymentAndRefreshBoard(deps: Pick<CreditOrchestrationDependencies, 'installmentService' | 'loanBoardService'>, payment: RecordInstallmentPaymentInput, scope: LoanBoardScope): Promise<RecordPaymentAndBoardResult>;
+export interface MemberCreditDashboardInput {
+    memberId: string;
+    boardScope: LoanBoardScope;
+    dueScope: LoanDueWindowScope;
+    dueWindow: LoanDueWindowQueryInput;
+}
+export interface MemberCreditDashboardResult {
+    board: LoanBoardItemContract[];
+    dueWindowItems: LoanDueWindowItemContract[];
+    loans: LoanContract[];
+}
+export declare function getMemberCreditDashboard(deps: CreditOrchestrationDependencies, input: MemberCreditDashboardInput): Promise<MemberCreditDashboardResult>;

package/dist/services/CreditOrchestrationService.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoanWithSchedule = createLoanWithSchedule;
+exports.recordPaymentAndRefreshBoard = recordPaymentAndRefreshBoard;
+exports.getMemberCreditDashboard = getMemberCreditDashboard;
+async function createLoanWithSchedule(deps, input) {
+    const loan = await deps.loanService.createLoan(input);
+    const installments = await deps.installmentService.generateInstallmentSchedule(loan.id);
+    return { loan, installments };
+}
+async function recordPaymentAndRefreshBoard(deps, payment, scope) {
+    const installment = await deps.installmentService.recordInstallmentPayment(payment);
+    const board = await deps.loanBoardService.listLoanBoard(scope, { memberId: undefined });
+    return { installment, board };
+}
+async function getMemberCreditDashboard(deps, input) {
+    const board = await deps.loanBoardService.listLoanBoard(input.boardScope, { memberId: input.memberId });
+    const dueWindowItems = await deps.loanDueWindowService.listLoansDueInWindow(input.dueScope, {
+        ...input.dueWindow,
+        memberId: input.memberId,
+    });
+    const loans = await deps.loanService.listLoansByMember(input.memberId, {
+        tenantId: input.boardScope.tenantId ?? null,
+        branchId: input.boardScope.branchId ?? null,
+    });
+    return { board, dueWindowItems, loans };
+}

package/dist/services/CreditPolicyService.d.ts

@@ -0,0 +1,4 @@
+import type { CreateCreditPolicyInput, CreditPolicyServiceContract } from '../contracts/CreditPolicyContract';
+export interface CreditPolicyService extends CreditPolicyServiceContract {
+}
+export declare function assertValidCreateCreditPolicyInput(input: CreateCreditPolicyInput): void;

package/dist/services/CreditPolicyService.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidCreateCreditPolicyInput = assertValidCreateCreditPolicyInput;
+const errors_1 = require("./errors");
+function assertValidCreateCreditPolicyInput(input) {
+    if (!input.policyCode?.trim())
+        throw (0, errors_1.invalidState)('policyCode is required');
+    if (input.penaltyRatePerDay < 0)
+        throw (0, errors_1.invalidState)('penaltyRatePerDay must be >= 0');
+    if (input.gracePeriodDays < 0)
+        throw (0, errors_1.invalidState)('gracePeriodDays must be >= 0');
+    if (input.maxTenorMonths <= 0)
+        throw (0, errors_1.invalidState)('maxTenorMonths must be > 0');
+}

package/dist/services/DailyCreditOpsService.d.ts

@@ -0,0 +1,2 @@
+export type { CreditOrchestrationDependencies as DailyCreditOpsDependencies, CreateLoanWithScheduleResult, RecordPaymentAndBoardResult, MemberCreditDashboardInput, MemberCreditDashboardResult, } from './CreditOrchestrationService';
+export { createLoanWithSchedule, recordPaymentAndRefreshBoard, getMemberCreditDashboard, } from './CreditOrchestrationService';

package/dist/services/DailyCreditOpsService.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemberCreditDashboard = exports.recordPaymentAndRefreshBoard = exports.createLoanWithSchedule = void 0;
+var CreditOrchestrationService_1 = require("./CreditOrchestrationService");
+Object.defineProperty(exports, "createLoanWithSchedule", { enumerable: true, get: function () { return CreditOrchestrationService_1.createLoanWithSchedule; } });
+Object.defineProperty(exports, "recordPaymentAndRefreshBoard", { enumerable: true, get: function () { return CreditOrchestrationService_1.recordPaymentAndRefreshBoard; } });
+Object.defineProperty(exports, "getMemberCreditDashboard", { enumerable: true, get: function () { return CreditOrchestrationService_1.getMemberCreditDashboard; } });

package/dist/services/InstallmentService.d.ts

@@ -0,0 +1,4 @@
+import type { InstallmentContract, InstallmentServiceContract } from '../contracts/InstallmentContract';
+export interface InstallmentService extends InstallmentServiceContract {
+}
+export declare function calculateInstallmentDueTotal(installment: Pick<InstallmentContract, 'principalDue' | 'serviceDue' | 'penaltyDue'>): number;

package/dist/services/InstallmentService.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateInstallmentDueTotal = calculateInstallmentDueTotal;
+function calculateInstallmentDueTotal(installment) {
+    return installment.principalDue + installment.serviceDue + installment.penaltyDue;
+}

package/dist/services/LoanBoardService.d.ts

@@ -0,0 +1,4 @@
+import type { LoanBoardServiceContract } from '../contracts/LoanBoardContract';
+export interface LoanBoardService extends LoanBoardServiceContract {
+}
+export declare function sumOutstandingAmount(values: number[]): number;

package/dist/services/LoanBoardService.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sumOutstandingAmount = sumOutstandingAmount;
+function sumOutstandingAmount(values) {
+    return values.reduce((sum, value) => sum + Math.max(0, value), 0);
+}

package/dist/services/LoanDueWindowService.d.ts

@@ -0,0 +1,4 @@
+import type { LoanDueWindowServiceContract } from '../contracts/LoanDueWindowContract';
+export interface LoanDueWindowService extends LoanDueWindowServiceContract {
+}
+export declare function calculateOutstandingAmount(dueAmount: number, paidAmount: number): number;

package/dist/services/LoanDueWindowService.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateOutstandingAmount = calculateOutstandingAmount;
+function calculateOutstandingAmount(dueAmount, paidAmount) {
+    return Math.max(0, dueAmount - paidAmount);
+}

package/dist/services/LoanService.d.ts

@@ -0,0 +1,4 @@
+import type { CreateLoanInput, LoanServiceContract } from '../contracts/LoanContract';
+export interface LoanService extends LoanServiceContract {
+}
+export declare function assertValidCreateLoanInput(input: CreateLoanInput): void;

package/dist/services/LoanService.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidCreateLoanInput = assertValidCreateLoanInput;
+const errors_1 = require("./errors");
+function assertValidCreateLoanInput(input) {
+    if (!input.memberId?.trim())
+        throw (0, errors_1.invalidState)('memberId is required');
+    if (!input.startDate?.trim())
+        throw (0, errors_1.invalidState)('startDate is required');
+    if (!input.tenantId?.trim())
+        throw (0, errors_1.invalidState)('tenantId is required');
+    if (input.principalAmount <= 0)
+        throw (0, errors_1.invalidState)('principalAmount must be > 0');
+    if (input.tenorMonths <= 0)
+        throw (0, errors_1.invalidState)('tenorMonths must be > 0');
+}

package/dist/services/createDbAdapterOfcoopCreditServices.d.ts

@@ -0,0 +1,16 @@
+import type { DbAdapter } from 'ofcore';
+import type { CreditPolicyServiceContract } from '../contracts/CreditPolicyContract';
+import type { InstallmentServiceContract } from '../contracts/InstallmentContract';
+import type { LoanBoardServiceContract } from '../contracts/LoanBoardContract';
+import type { LoanDueWindowServiceContract } from '../contracts/LoanDueWindowContract';
+import type { LoanServiceContract } from '../contracts/LoanContract';
+import type { ServiceRuntimeOptions } from './impl/runtimeSupport';
+export type { OfcoopCreditDomainEvent, OfcoopCreditDomainEventName, ServiceRuntimeOptions } from './impl/runtimeSupport';
+export interface OfcoopCreditDomainServices {
+    loanService: LoanServiceContract;
+    installmentService: InstallmentServiceContract;
+    creditPolicyService: CreditPolicyServiceContract;
+    loanBoardService: LoanBoardServiceContract;
+    loanDueWindowService: LoanDueWindowServiceContract;
+}
+export declare function createDbAdapterOfcoopCreditServices(dbAdapter: DbAdapter, options?: ServiceRuntimeOptions): Promise<OfcoopCreditDomainServices>;

package/dist/services/createDbAdapterOfcoopCreditServices.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDbAdapterOfcoopCreditServices = createDbAdapterOfcoopCreditServices;
+const repositories_1 = require("../data/repositories");
+const DbAdapterCreditPolicyService_1 = require("./impl/DbAdapterCreditPolicyService");
+const DbAdapterInstallmentService_1 = require("./impl/DbAdapterInstallmentService");
+const DbAdapterLoanBoardService_1 = require("./impl/DbAdapterLoanBoardService");
+const DbAdapterLoanDueWindowService_1 = require("./impl/DbAdapterLoanDueWindowService");
+const DbAdapterLoanService_1 = require("./impl/DbAdapterLoanService");
+async function createDbAdapterOfcoopCreditServices(dbAdapter, options = {}) {
+    const repositories = (0, repositories_1.createOfcoopCreditRepositories)(dbAdapter);
+    return {
+        loanService: new DbAdapterLoanService_1.DbAdapterLoanService(repositories, options),
+        installmentService: new DbAdapterInstallmentService_1.DbAdapterInstallmentService(dbAdapter, repositories, options),
+        creditPolicyService: new DbAdapterCreditPolicyService_1.DbAdapterCreditPolicyService(repositories, options),
+        loanBoardService: new DbAdapterLoanBoardService_1.DbAdapterLoanBoardService(repositories),
+        loanDueWindowService: new DbAdapterLoanDueWindowService_1.DbAdapterLoanDueWindowService(repositories),
+    };
+}

package/dist/services/errors.d.ts

@@ -0,0 +1,8 @@
+export type OfcoopCreditErrorCode = 'RESOURCE_NOT_FOUND' | 'CONFLICT' | 'INVALID_STATE';
+export declare class OfcoopCreditDomainError extends Error {
+    readonly code: OfcoopCreditErrorCode;
+    constructor(code: OfcoopCreditErrorCode, message: string);
+}
+export declare function notFound(entity: string, id: string): OfcoopCreditDomainError;
+export declare function conflict(message: string): OfcoopCreditDomainError;
+export declare function invalidState(message: string): OfcoopCreditDomainError;

package/dist/services/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfcoopCreditDomainError = void 0;
+exports.notFound = notFound;
+exports.conflict = conflict;
+exports.invalidState = invalidState;
+class OfcoopCreditDomainError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'OfcoopCreditDomainError';
+    }
+}
+exports.OfcoopCreditDomainError = OfcoopCreditDomainError;
+function notFound(entity, id) {
+    return new OfcoopCreditDomainError('RESOURCE_NOT_FOUND', `${entity} not found: ${id}`);
+}
+function conflict(message) {
+    return new OfcoopCreditDomainError('CONFLICT', message);
+}
+function invalidState(message) {
+    return new OfcoopCreditDomainError('INVALID_STATE', message);
+}

package/dist/services/impl/DbAdapterCreditPolicyService.d.ts

@@ -0,0 +1,12 @@
+import type { CreateCreditPolicyInput, CreditPolicyContract, CreditPolicyScope, CreditPolicyServiceContract, UpdateCreditPolicyInput } from '../../contracts/CreditPolicyContract';
+import type { OfcoopCreditRepositories } from '../../data/repositories';
+import { type ServiceRuntimeOptions } from './runtimeSupport';
+export declare class DbAdapterCreditPolicyService implements CreditPolicyServiceContract {
+    private readonly repos;
+    private readonly options;
+    private readonly newId;
+    constructor(repos: OfcoopCreditRepositories, options?: ServiceRuntimeOptions);
+    createCreditPolicy(input: CreateCreditPolicyInput): Promise<CreditPolicyContract>;
+    updateCreditPolicy(id: string, updates: UpdateCreditPolicyInput): Promise<CreditPolicyContract>;
+    getActiveCreditPolicy(scope: CreditPolicyScope): Promise<CreditPolicyContract | null>;
+}

package/dist/services/impl/DbAdapterCreditPolicyService.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbAdapterCreditPolicyService = void 0;
+const errors_1 = require("../errors");
+const CreditPolicyService_1 = require("../CreditPolicyService");
+const runtimeSupport_1 = require("./runtimeSupport");
+class DbAdapterCreditPolicyService {
+    constructor(repos, options = {}) {
+        this.repos = repos;
+        this.options = options;
+        this.newId = (0, runtimeSupport_1.makeIdFactory)('credit-policy');
+    }
+    async createCreditPolicy(input) {
+        (0, CreditPolicyService_1.assertValidCreateCreditPolicyInput)(input);
+        const created = await this.repos.creditPolicyRepository.create({
+            id: this.newId(),
+            policyCode: input.policyCode,
+            penaltyRatePerDay: input.penaltyRatePerDay,
+            gracePeriodDays: input.gracePeriodDays,
+            maxTenorMonths: input.maxTenorMonths,
+            isActive: input.isActive ?? true,
+            branchId: input.branchId ?? null,
+            tenantId: input.tenantId ?? null,
+            version: 1,
+            lastModified: (0, runtimeSupport_1.nowIso)(),
+            deleted: false,
+        });
+        await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+            name: 'credit-policy.created',
+            occurredAt: (0, runtimeSupport_1.nowIso)(),
+            entityId: created.id,
+            tenantId: created.tenantId ?? null,
+            branchId: created.branchId ?? null,
+            payload: { policyCode: created.policyCode },
+        });
+        return created;
+    }
+    async updateCreditPolicy(id, updates) {
+        const current = await this.repos.creditPolicyRepository.getById(id);
+        if (!current || current.deleted)
+            throw (0, errors_1.notFound)('Credit policy', id);
+        const updated = await this.repos.creditPolicyRepository.update(id, {
+            ...updates,
+            version: current.version + 1,
+            lastModified: (0, runtimeSupport_1.nowIso)(),
+        });
+        await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+            name: 'credit-policy.updated',
+            occurredAt: (0, runtimeSupport_1.nowIso)(),
+            entityId: updated.id,
+            tenantId: updated.tenantId ?? null,
+            branchId: updated.branchId ?? null,
+            payload: { policyCode: updated.policyCode },
+        });
+        return updated;
+    }
+    async getActiveCreditPolicy(scope) {
+        return this.repos.creditPolicyRepository.getActive(scope);
+    }
+}
+exports.DbAdapterCreditPolicyService = DbAdapterCreditPolicyService;

package/dist/services/impl/DbAdapterInstallmentService.d.ts

@@ -0,0 +1,16 @@
+import type { DbAdapter } from 'ofcore';
+import type { InstallmentContract, InstallmentQueryOptions, InstallmentServiceContract, RecordInstallmentPaymentInput } from '../../contracts/InstallmentContract';
+import { type OfcoopCreditRepositories } from '../../data/repositories';
+import { type ServiceRuntimeOptions } from './runtimeSupport';
+export declare class DbAdapterInstallmentService implements InstallmentServiceContract {
+    private readonly db;
+    private readonly repos;
+    private readonly options;
+    private readonly newId;
+    constructor(db: DbAdapter, repos: OfcoopCreditRepositories, options?: ServiceRuntimeOptions);
+    private inTx;
+    generateInstallmentSchedule(loanId: string): Promise<InstallmentContract[]>;
+    recordInstallmentPayment(input: RecordInstallmentPaymentInput): Promise<InstallmentContract>;
+    listInstallmentsByLoan(loanId: string, options?: InstallmentQueryOptions): Promise<InstallmentContract[]>;
+    listOverdueInstallments(options?: InstallmentQueryOptions): Promise<InstallmentContract[]>;
+}