ofcoop-shared-core 0.1.0-alpha.0

package/dist/services/errors.d.ts

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

package/dist/services/errors.js

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

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

@@ -0,0 +1,9 @@
+import type { MemberNumberPolicyContract, MemberNumberPolicyScope, MemberNumberPolicyServiceContract, UpsertMemberNumberPolicyInput } from '../../contracts/MemberNumberPolicyContract';
+import type { OfcoopRepositories } from '../../data/repositories';
+export declare class DbAdapterMemberNumberPolicyService implements MemberNumberPolicyServiceContract {
+    private readonly repos;
+    private readonly newId;
+    constructor(repos: OfcoopRepositories);
+    getActiveMemberNumberPolicy(scope: MemberNumberPolicyScope): Promise<MemberNumberPolicyContract | null>;
+    upsertMemberNumberPolicy(input: UpsertMemberNumberPolicyInput): Promise<MemberNumberPolicyContract>;
+}

package/dist/services/impl/DbAdapterMemberNumberPolicyService.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbAdapterMemberNumberPolicyService = void 0;
+const MemberNumberPolicyService_1 = require("../MemberNumberPolicyService");
+const runtimeSupport_1 = require("./runtimeSupport");
+class DbAdapterMemberNumberPolicyService {
+    constructor(repos) {
+        this.repos = repos;
+        this.newId = (0, runtimeSupport_1.makeIdFactory)('member-number-policy');
+    }
+    async getActiveMemberNumberPolicy(scope) {
+        return this.repos.memberNumberPolicyRepository.getActive(scope);
+    }
+    async upsertMemberNumberPolicy(input) {
+        (0, MemberNumberPolicyService_1.assertValidMemberNumberPolicyInput)(input);
+        const scope = { koperasiId: input.koperasiId, tenantId: input.tenantId, branchId: input.branchId };
+        const current = await this.repos.memberNumberPolicyRepository.getActive(scope);
+        const now = (0, runtimeSupport_1.nowIso)();
+        if (current) {
+            return this.repos.memberNumberPolicyRepository.upsert({
+                ...current,
+                ...input,
+                version: current.version + 1,
+                lastModified: now,
+            });
+        }
+        return this.repos.memberNumberPolicyRepository.upsert({
+            id: this.newId(),
+            ...input,
+            approvalRef: input.approvalRef ?? null,
+            version: 1,
+            lastModified: now,
+            deleted: false,
+        });
+    }
+}
+exports.DbAdapterMemberNumberPolicyService = DbAdapterMemberNumberPolicyService;

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

@@ -0,0 +1,21 @@
+import type { DbAdapter } from 'ofcore';
+import type { CreateMemberInput, MemberContract, MemberExitInput, MemberQueryOptions, MemberServiceContract, MemberStatus, MemberWaConsentInput, UpdateMemberInput } from '../../contracts/MemberContract';
+import { type OfcoopRepositories } from '../../data/repositories';
+import { type ServiceRuntimeOptions } from './runtimeSupport';
+export declare class DbAdapterMemberService implements MemberServiceContract {
+    private readonly db;
+    private readonly repos;
+    private readonly options;
+    private readonly newId;
+    constructor(db: DbAdapter, repos: OfcoopRepositories, options?: ServiceRuntimeOptions);
+    private inTx;
+    createMember(input: CreateMemberInput): Promise<MemberContract>;
+    updateMember(id: string, updates: UpdateMemberInput): Promise<MemberContract>;
+    getMemberById(id: string): Promise<MemberContract | null>;
+    listMembers(options?: MemberQueryOptions): Promise<MemberContract[]>;
+    changeMemberStatus(id: string, status: MemberStatus): Promise<MemberContract>;
+    setMemberWaConsent(id: string, consent: MemberWaConsentInput): Promise<MemberContract>;
+    requestMemberExit(id: string, payload: MemberExitInput): Promise<MemberContract>;
+    settleMemberExit(id: string, payload: MemberExitInput): Promise<MemberContract>;
+    cancelMemberExit(id: string, payload: MemberExitInput): Promise<MemberContract>;
+}

package/dist/services/impl/DbAdapterMemberService.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbAdapterMemberService = void 0;
+const repositories_1 = require("../../data/repositories");
+const errors_1 = require("../errors");
+const MemberService_1 = require("../MemberService");
+const runtimeSupport_1 = require("./runtimeSupport");
+class DbAdapterMemberService {
+    constructor(db, repos, options = {}) {
+        this.db = db;
+        this.repos = repos;
+        this.options = options;
+        this.newId = (0, runtimeSupport_1.makeIdFactory)('member');
+    }
+    async inTx(callback) {
+        return this.db.transaction(async (tx) => callback((0, repositories_1.createOfcoopRepositories)(tx)));
+    }
+    async createMember(input) {
+        (0, MemberService_1.assertValidCreateMemberInput)(input);
+        const existing = await this.repos.memberRepository.list({ tenantId: input.tenantId ?? null });
+        if (existing.some((member) => member.memberNumber === input.memberNumber && !member.deleted)) {
+            throw (0, errors_1.conflict)(`Member number already exists: ${input.memberNumber}`);
+        }
+        const result = await this.repos.memberRepository.create({
+            id: this.newId(),
+            memberNumber: input.memberNumber,
+            fullName: input.fullName,
+            status: 'active',
+            joinDate: input.joinDate,
+            exitDate: null,
+            branchId: input.branchId ?? null,
+            tenantId: input.tenantId ?? null,
+            version: 1,
+            lastModified: (0, runtimeSupport_1.nowIso)(),
+            deleted: false,
+        });
+        this.options.logger?.logInfo('[ofcoop] member created', { memberId: result.id, tenantId: result.tenantId, branchId: result.branchId });
+        await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+            name: 'member.created',
+            occurredAt: (0, runtimeSupport_1.nowIso)(),
+            entityId: result.id,
+            tenantId: result.tenantId ?? null,
+            branchId: result.branchId ?? null,
+            payload: { memberNumber: result.memberNumber },
+        });
+        return result;
+    }
+    async updateMember(id, updates) {
+        const row = await this.repos.memberRepository.getById(id);
+        if (!row || row.deleted)
+            throw (0, errors_1.notFound)('Member', id);
+        const updated = await this.repos.memberRepository.update(id, {
+            ...(updates.fullName !== undefined ? { fullName: updates.fullName } : {}),
+            ...(updates.memberNumber !== undefined ? { memberNumber: updates.memberNumber } : {}),
+            version: row.version + 1,
+            lastModified: (0, runtimeSupport_1.nowIso)(),
+        });
+        this.options.logger?.logInfo('[ofcoop] member updated', { memberId: id });
+        await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+            name: 'member.updated',
+            occurredAt: (0, runtimeSupport_1.nowIso)(),
+            entityId: updated.id,
+            tenantId: updated.tenantId ?? null,
+            branchId: updated.branchId ?? null,
+            payload: { memberNumber: updated.memberNumber },
+        });
+        return updated;
+    }
+    async getMemberById(id) {
+        const row = await this.repos.memberRepository.getById(id);
+        if (!row || row.deleted)
+            return null;
+        return row;
+    }
+    async listMembers(options) {
+        return this.repos.memberRepository.list(options);
+    }
+    async changeMemberStatus(id, status) {
+        const row = await this.repos.memberRepository.getById(id);
+        if (!row || row.deleted)
+            throw (0, errors_1.notFound)('Member', id);
+        return this.repos.memberRepository.update(id, {
+            status,
+            version: row.version + 1,
+            lastModified: (0, runtimeSupport_1.nowIso)(),
+        });
+    }
+    async setMemberWaConsent(id, consent) {
+        return this.inTx(async (repos) => {
+            const row = await repos.memberRepository.getById(id);
+            if (!row || row.deleted)
+                throw (0, errors_1.notFound)('Member', id);
+            await repos.memberWaConsentRepository.set(id, consent);
+            return repos.memberRepository.update(id, {
+                version: row.version + 1,
+                lastModified: (0, runtimeSupport_1.nowIso)(),
+            });
+        });
+    }
+    async requestMemberExit(id, payload) {
+        return this.inTx(async (repos) => {
+            const row = await repos.memberRepository.getById(id);
+            if (!row || row.deleted)
+                throw (0, errors_1.notFound)('Member', id);
+            await repos.memberExitStateRepository.set(id, 'requested', payload);
+            return repos.memberRepository.update(id, {
+                status: 'inactive',
+                version: row.version + 1,
+                lastModified: (0, runtimeSupport_1.nowIso)(),
+            });
+        });
+    }
+    async settleMemberExit(id, payload) {
+        return this.inTx(async (repos) => {
+            const row = await repos.memberRepository.getById(id);
+            if (!row || row.deleted)
+                throw (0, errors_1.notFound)('Member', id);
+            await repos.memberExitStateRepository.set(id, 'settled', payload);
+            return repos.memberRepository.update(id, {
+                status: 'exited',
+                exitDate: (0, runtimeSupport_1.nowIso)(),
+                version: row.version + 1,
+                lastModified: (0, runtimeSupport_1.nowIso)(),
+            });
+        });
+    }
+    async cancelMemberExit(id, payload) {
+        return this.inTx(async (repos) => {
+            const row = await repos.memberRepository.getById(id);
+            if (!row || row.deleted)
+                throw (0, errors_1.notFound)('Member', id);
+            await repos.memberExitStateRepository.set(id, 'canceled', payload);
+            return repos.memberRepository.update(id, {
+                status: 'active',
+                exitDate: null,
+                version: row.version + 1,
+                lastModified: (0, runtimeSupport_1.nowIso)(),
+            });
+        });
+    }
+}
+exports.DbAdapterMemberService = DbAdapterMemberService;

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

@@ -0,0 +1,9 @@
+import type { SavingComplianceSnapshotContract, SavingComplianceSnapshotQueryOptions, SavingComplianceSnapshotScope, SavingComplianceSnapshotServiceContract } from '../../contracts/SavingComplianceSnapshotContract';
+import type { OfcoopRepositories } from '../../data/repositories';
+export declare class DbAdapterSavingComplianceSnapshotService implements SavingComplianceSnapshotServiceContract {
+    private readonly repos;
+    constructor(repos: OfcoopRepositories);
+    private buildSnapshot;
+    listComplianceSnapshots(scope: SavingComplianceSnapshotScope, options?: SavingComplianceSnapshotQueryOptions): Promise<SavingComplianceSnapshotContract[]>;
+    getComplianceSnapshotByMember(memberId: string, scope: SavingComplianceSnapshotScope): Promise<SavingComplianceSnapshotContract | null>;
+}

package/dist/services/impl/DbAdapterSavingComplianceSnapshotService.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbAdapterSavingComplianceSnapshotService = void 0;
+const SavingComplianceSnapshotService_1 = require("../SavingComplianceSnapshotService");
+const runtimeSupport_1 = require("./runtimeSupport");
+class DbAdapterSavingComplianceSnapshotService {
+    constructor(repos) {
+        this.repos = repos;
+    }
+    async buildSnapshot(member, scope, policy) {
+        const memberEntries = await this.repos.savingLedgerRepository.listByMember(member.id, {
+            includeDeleted: false,
+            tenantId: scope.tenantId,
+            branchId: scope.branchId ?? null,
+        });
+        const wajibEntries = memberEntries.filter((entry) => entry.savingType === 'wajib');
+        const wajibCreditTotalIdr = wajibEntries
+            .filter((entry) => entry.entryType === 'credit')
+            .reduce((sum, entry) => sum + entry.amount, 0);
+        const wajibDebitTotalIdr = wajibEntries
+            .filter((entry) => entry.entryType === 'debit')
+            .reduce((sum, entry) => sum + entry.amount, 0);
+        const wajibNetTotalIdr = wajibCreditTotalIdr - wajibDebitTotalIdr;
+        const monthlyWajibNominalIdr = policy?.monthlyWajibNominalIdr ?? 0;
+        const status = (0, SavingComplianceSnapshotService_1.deriveSavingComplianceStatus)(monthlyWajibNominalIdr, wajibNetTotalIdr, Boolean(policy));
+        const monthsInArrears = status === 'underpaid' ? 1 : 0;
+        const recommendedAction = status === 'compliant' ? 'none' : status === 'no-policy' ? 'set_active_saving_policy' : 'followup_wajib_payment';
+        return {
+            id: `snapshot-${member.id}`,
+            memberId: member.id,
+            koperasiId: scope.koperasiId,
+            tenantId: member.tenantId ?? null,
+            branchId: member.branchId ?? null,
+            referenceDate: (0, runtimeSupport_1.nowIso)(),
+            monthlyWajibNominalIdr,
+            wajibCreditTotalIdr,
+            wajibDebitTotalIdr,
+            wajibNetTotalIdr,
+            status,
+            monthsInArrears,
+            recommendedAction,
+            metadata: {
+                memberNumber: member.memberNumber,
+            },
+            version: 1,
+            lastModified: (0, runtimeSupport_1.nowIso)(),
+            deleted: false,
+        };
+    }
+    async listComplianceSnapshots(scope, options) {
+        const policy = await this.repos.savingPolicyRepository.getActive({
+            koperasiId: scope.koperasiId,
+            tenantId: scope.tenantId,
+            branchId: scope.branchId ?? null,
+        });
+        const members = await this.repos.memberRepository.list({
+            includeDeleted: options?.includeDeleted ?? false,
+            status: 'active',
+            tenantId: scope.tenantId,
+            branchId: scope.branchId ?? null,
+        });
+        const snapshots = await Promise.all(members
+            .filter((member) => (options?.memberId ? member.id === options.memberId : true))
+            .map((member) => this.buildSnapshot(member, scope, policy)));
+        return snapshots
+            .filter((snapshot) => (options?.status ? snapshot.status === options.status : true))
+            .map((snapshot) => (0, runtimeSupport_1.clone)(snapshot));
+    }
+    async getComplianceSnapshotByMember(memberId, scope) {
+        const snapshots = await this.listComplianceSnapshots(scope, { memberId });
+        return snapshots[0] ?? null;
+    }
+}
+exports.DbAdapterSavingComplianceSnapshotService = DbAdapterSavingComplianceSnapshotService;

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

@@ -0,0 +1,18 @@
+import type { DbAdapter } from 'ofcore';
+import type { SavingBalance, SavingEntryInput, SavingLedgerContract, SavingLedgerQueryOptions, SavingLedgerServiceContract } from '../../contracts/SavingLedgerContract';
+import { type OfcoopRepositories } from '../../data/repositories';
+import { type ServiceRuntimeOptions } from './runtimeSupport';
+export declare class DbAdapterSavingLedgerService implements SavingLedgerServiceContract {
+    private readonly db;
+    private readonly repos;
+    private readonly options;
+    private readonly newId;
+    constructor(db: DbAdapter, repos: OfcoopRepositories, options?: ServiceRuntimeOptions);
+    private inTx;
+    private addEntry;
+    recordSavingCredit(input: SavingEntryInput): Promise<SavingLedgerContract>;
+    recordSavingDebit(input: SavingEntryInput): Promise<SavingLedgerContract>;
+    recordSavingWithdrawal(input: SavingEntryInput): Promise<SavingLedgerContract>;
+    listSavingEntriesByMember(memberId: string, options?: SavingLedgerQueryOptions): Promise<SavingLedgerContract[]>;
+    getSavingBalanceByMember(memberId: string): Promise<SavingBalance>;
+}

package/dist/services/impl/DbAdapterSavingLedgerService.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbAdapterSavingLedgerService = void 0;
+const repositories_1 = require("../../data/repositories");
+const errors_1 = require("../errors");
+const SavingLedgerService_1 = require("../SavingLedgerService");
+const runtimeSupport_1 = require("./runtimeSupport");
+class DbAdapterSavingLedgerService {
+    constructor(db, repos, options = {}) {
+        this.db = db;
+        this.repos = repos;
+        this.options = options;
+        this.newId = (0, runtimeSupport_1.makeIdFactory)('saving-ledger');
+    }
+    async inTx(callback) {
+        return this.db.transaction(async (tx) => callback((0, repositories_1.createOfcoopRepositories)(tx)));
+    }
+    async addEntry(type, input) {
+        (0, SavingLedgerService_1.assertValidSavingEntryInput)(input);
+        return this.inTx(async (repos) => {
+            const member = await repos.memberRepository.getById(input.memberId);
+            if (!member || member.deleted)
+                throw (0, errors_1.notFound)('Member', input.memberId);
+            if (member.status !== 'active') {
+                throw (0, errors_1.conflict)(`Cannot record saving entry for inactive member: ${input.memberId}`);
+            }
+            if (input.referenceType && input.referenceId) {
+                const duplicate = await repos.savingLedgerRepository.findByReference({
+                    memberId: input.memberId,
+                    savingType: input.savingType,
+                    entryType: type,
+                    referenceType: input.referenceType,
+                    referenceId: input.referenceId,
+                    tenantId: input.tenantId ?? null,
+                    branchId: input.branchId ?? null,
+                });
+                if (duplicate) {
+                    this.options.logger?.logInfo('[ofcoop] saving entry idempotent hit', {
+                        memberId: input.memberId,
+                        referenceType: input.referenceType,
+                        referenceId: input.referenceId,
+                    });
+                    return duplicate;
+                }
+            }
+            const created = await repos.savingLedgerRepository.create({
+                id: this.newId(),
+                memberId: input.memberId,
+                savingType: input.savingType,
+                entryType: type,
+                amount: input.amount,
+                transactionDate: input.transactionDate,
+                referenceType: input.referenceType ?? null,
+                referenceId: input.referenceId ?? null,
+                notes: input.notes ?? null,
+                branchId: input.branchId ?? null,
+                tenantId: input.tenantId ?? null,
+                version: 1,
+                lastModified: (0, runtimeSupport_1.nowIso)(),
+                deleted: false,
+            });
+            this.options.logger?.logInfo('[ofcoop] saving entry recorded', {
+                entryId: created.id,
+                memberId: created.memberId,
+                savingType: created.savingType,
+                entryType: created.entryType,
+                amount: created.amount,
+            });
+            await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+                name: 'saving.entry-recorded',
+                occurredAt: (0, runtimeSupport_1.nowIso)(),
+                entityId: created.id,
+                tenantId: created.tenantId ?? null,
+                branchId: created.branchId ?? null,
+                payload: {
+                    memberId: created.memberId,
+                    savingType: created.savingType,
+                    entryType: created.entryType,
+                    amount: created.amount,
+                },
+            });
+            return created;
+        });
+    }
+    async recordSavingCredit(input) {
+        return this.addEntry('credit', input);
+    }
+    async recordSavingDebit(input) {
+        return this.addEntry('debit', input);
+    }
+    async recordSavingWithdrawal(input) {
+        if (input.savingType !== 'sukarela') {
+            throw (0, errors_1.conflict)(`recordSavingWithdrawal only supports sukarela saving type, received: ${input.savingType}`);
+        }
+        const balance = await this.getSavingBalanceByMember(input.memberId);
+        if (input.amount > balance.sukarela) {
+            throw (0, errors_1.conflict)(`Insufficient sukarela balance for member: ${input.memberId}`);
+        }
+        return this.addEntry('debit', { ...input, notes: input.notes ?? 'withdrawal' });
+    }
+    async listSavingEntriesByMember(memberId, options) {
+        return this.repos.savingLedgerRepository.listByMember(memberId, options);
+    }
+    async getSavingBalanceByMember(memberId) {
+        const entries = await this.listSavingEntriesByMember(memberId);
+        const balance = { pokok: 0, wajib: 0, sukarela: 0, total: 0 };
+        for (const entry of entries) {
+            const sign = entry.entryType === 'credit' ? 1 : -1;
+            balance[entry.savingType] += sign * entry.amount;
+        }
+        balance.total = balance.pokok + balance.wajib + balance.sukarela;
+        return balance;
+    }
+}
+exports.DbAdapterSavingLedgerService = DbAdapterSavingLedgerService;

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

@@ -0,0 +1,14 @@
+import type { SavingComplianceEvaluation, SavingComplianceWorklistItem, SavingPolicyContract, SavingPolicyScope, SavingPolicyServiceContract, UpsertSavingPolicyInput } from '../../contracts/SavingPolicyContract';
+import type { OfcoopRepositories } from '../../data/repositories';
+import { type ServiceRuntimeOptions } from './runtimeSupport';
+export declare class DbAdapterSavingPolicyService implements SavingPolicyServiceContract {
+    private readonly repos;
+    private readonly options;
+    private readonly newId;
+    constructor(repos: OfcoopRepositories, options?: ServiceRuntimeOptions);
+    getActiveSavingPolicy(scope: SavingPolicyScope): Promise<SavingPolicyContract | null>;
+    upsertSavingPolicy(input: UpsertSavingPolicyInput): Promise<SavingPolicyContract>;
+    evaluateWajibCompliance(scope: SavingPolicyScope): Promise<SavingComplianceEvaluation>;
+    getComplianceWorklist(scope: SavingPolicyScope): Promise<SavingComplianceWorklistItem[]>;
+    private monthDiffInclusive;
+}

package/dist/services/impl/DbAdapterSavingPolicyService.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbAdapterSavingPolicyService = void 0;
+const SavingPolicyService_1 = require("../SavingPolicyService");
+const runtimeSupport_1 = require("./runtimeSupport");
+class DbAdapterSavingPolicyService {
+    constructor(repos, options = {}) {
+        this.repos = repos;
+        this.options = options;
+        this.newId = (0, runtimeSupport_1.makeIdFactory)('saving-policy');
+    }
+    async getActiveSavingPolicy(scope) {
+        return this.repos.savingPolicyRepository.getActive(scope);
+    }
+    async upsertSavingPolicy(input) {
+        (0, SavingPolicyService_1.assertValidSavingPolicyInput)(input);
+        const scope = { koperasiId: input.koperasiId, tenantId: input.tenantId, branchId: input.branchId };
+        const current = await this.repos.savingPolicyRepository.getActive(scope);
+        const now = (0, runtimeSupport_1.nowIso)();
+        if (current) {
+            const updated = await this.repos.savingPolicyRepository.upsert({
+                ...current,
+                ...input,
+                changeReason: input.changeReason ?? null,
+                approvalRef: input.approvalRef ?? null,
+                version: current.version + 1,
+                lastModified: now,
+            });
+            await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+                name: 'saving.policy-upserted',
+                occurredAt: (0, runtimeSupport_1.nowIso)(),
+                entityId: updated.id,
+                tenantId: updated.tenantId ?? null,
+                branchId: updated.branchId ?? null,
+                payload: { effectiveDate: updated.effectiveDate },
+            });
+            return updated;
+        }
+        const created = await this.repos.savingPolicyRepository.upsert({
+            id: this.newId(),
+            ...input,
+            changeReason: input.changeReason ?? null,
+            approvalRef: input.approvalRef ?? null,
+            version: 1,
+            lastModified: now,
+            deleted: false,
+        });
+        await (0, runtimeSupport_1.emitDomainEvent)(this.options, {
+            name: 'saving.policy-upserted',
+            occurredAt: (0, runtimeSupport_1.nowIso)(),
+            entityId: created.id,
+            tenantId: created.tenantId ?? null,
+            branchId: created.branchId ?? null,
+            payload: { effectiveDate: created.effectiveDate },
+        });
+        return created;
+    }
+    async evaluateWajibCompliance(scope) {
+        const policy = await this.getActiveSavingPolicy(scope);
+        const entries = await this.repos.savingLedgerRepository.listAll({
+            includeDeleted: false,
+            tenantId: scope.tenantId,
+            branchId: scope.branchId ?? null,
+        });
+        const wajibEntries = entries.filter((entry) => entry.savingType === 'wajib');
+        const totalWajibCredit = wajibEntries
+            .filter((entry) => entry.entryType === 'credit')
+            .reduce((sum, entry) => sum + entry.amount, 0);
+        const totalWajibDebit = wajibEntries
+            .filter((entry) => entry.entryType === 'debit')
+            .reduce((sum, entry) => sum + entry.amount, 0);
+        return {
+            summary: {
+                activePolicy: policy ? 1 : 0,
+                wajibCreditTotal: totalWajibCredit,
+                wajibDebitTotal: totalWajibDebit,
+                wajibNetTotal: (0, SavingPolicyService_1.calculateWajibNetTotal)(totalWajibCredit, totalWajibDebit),
+            },
+            referenceDate: (0, runtimeSupport_1.nowIso)(),
+        };
+    }
+    async getComplianceWorklist(scope) {
+        const policy = await this.getActiveSavingPolicy(scope);
+        if (!policy)
+            return [];
+        const members = await this.repos.memberRepository.list({
+            includeDeleted: false,
+            status: 'active',
+            tenantId: scope.tenantId,
+            branchId: scope.branchId ?? null,
+        });
+        const now = new Date();
+        return Promise.all(members.map(async (member) => {
+            const entries = await this.repos.savingLedgerRepository.listByMember(member.id, {
+                tenantId: scope.tenantId,
+                branchId: scope.branchId ?? null,
+            });
+            const wajibNet = entries.reduce((sum, entry) => {
+                if (entry.savingType !== 'wajib')
+                    return sum;
+                return sum + (entry.entryType === 'credit' ? entry.amount : -entry.amount);
+            }, 0);
+            const monthsSinceJoin = Math.max(1, this.monthDiffInclusive(member.joinDate, now.toISOString().slice(0, 10)));
+            const expectedWajib = monthsSinceJoin * policy.monthlyWajibNominalIdr;
+            const arrearsAmount = Math.max(0, expectedWajib - wajibNet);
+            const monthsInArrears = policy.monthlyWajibNominalIdr > 0 ? Math.ceil(arrearsAmount / policy.monthlyWajibNominalIdr) : 0;
+            const daysInArrears = monthsInArrears * 30;
+            const priority = daysInArrears > 90 ? 'critical' : daysInArrears > 30 ? 'high' : daysInArrears > 7 ? 'medium' : 'low';
+            return {
+                id: `worklist-${member.id}`,
+                memberId: member.id,
+                priority,
+                reasonCode: 'WJ-REVIEW',
+                reasonText: `Review wajib compliance for member ${member.memberNumber}`,
+                recommendedAction: 'verify_monthly_wajib',
+                metadata: {
+                    policyId: policy.id,
+                    memberNumber: member.memberNumber,
+                    fullName: member.fullName,
+                    expectedWajib,
+                    wajibNet,
+                    arrearsAmount,
+                    monthsInArrears,
+                    daysInArrears,
+                },
+            };
+        }));
+    }
+    monthDiffInclusive(fromDate, toDate) {
+        const from = new Date(fromDate);
+        const to = new Date(toDate);
+        if (Number.isNaN(from.getTime()) || Number.isNaN(to.getTime()))
+            return 1;
+        const yearDiff = to.getUTCFullYear() - from.getUTCFullYear();
+        const monthDiff = to.getUTCMonth() - from.getUTCMonth();
+        return yearDiff * 12 + monthDiff + 1;
+    }
+}
+exports.DbAdapterSavingPolicyService = DbAdapterSavingPolicyService;

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

@@ -0,0 +1,12 @@
+import type { ShuConfigContract, ShuConfigQueryOptions, ShuConfigScope, ShuConfigServiceContract, UpsertShuConfigInput } from '../../contracts/ShuConfigContract';
+import type { OfcoopRepositories } from '../../data/repositories';
+import { type ServiceRuntimeOptions } from './runtimeSupport';
+export declare class DbAdapterShuConfigService implements ShuConfigServiceContract {
+    private readonly repos;
+    private readonly options;
+    private readonly newId;
+    constructor(repos: OfcoopRepositories, options?: ServiceRuntimeOptions);
+    getActiveShuConfig(scope: ShuConfigScope): Promise<ShuConfigContract | null>;
+    upsertShuConfig(input: UpsertShuConfigInput): Promise<ShuConfigContract>;
+    listShuConfigs(scope: ShuConfigScope, options?: ShuConfigQueryOptions): Promise<ShuConfigContract[]>;
+}