ofcoop-shared-core 0.1.0-alpha.0

package/dist/contracts/ShuContract.d.ts

@@ -0,0 +1,58 @@
+export type ShuPeriodStatus = 'draft' | 'finalized';
+export interface ShuPeriodContract {
+    id: string;
+    periodCode: string;
+    startDate: string;
+    endDate: string;
+    status: ShuPeriodStatus;
+    formulaSnapshot: Record<string, unknown>;
+    branchId?: string | null;
+    tenantId?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface ShuAllocationContract {
+    id: string;
+    shuPeriodId: string;
+    memberId: string;
+    allocationAmount: number;
+    calculationBasis: Record<string, unknown>;
+    branchId?: string | null;
+    tenantId?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface CreateShuPeriodInput {
+    periodCode: string;
+    startDate: string;
+    endDate: string;
+    formulaSnapshot: Record<string, unknown>;
+    branchId?: string | null;
+    tenantId?: string | null;
+}
+export interface ShuAllocationQueryOptions {
+    includeDeleted?: boolean;
+    memberId?: string;
+}
+export interface ShuPeriodQueryOptions {
+    includeDeleted?: boolean;
+    tenantId?: string | null;
+    branchId?: string | null;
+    status?: ShuPeriodStatus;
+    dateContains?: string;
+}
+export interface CsvExportPayload {
+    filename: string;
+    contentType: string;
+    body: string;
+}
+export interface ShuServiceContract {
+    createShuPeriod(input: CreateShuPeriodInput): Promise<ShuPeriodContract>;
+    finalizeShuPeriod(periodId: string): Promise<ShuPeriodContract>;
+    listShuPeriods(options?: ShuPeriodQueryOptions): Promise<ShuPeriodContract[]>;
+    generateShuAllocations(periodId: string): Promise<ShuAllocationContract[]>;
+    listShuAllocations(periodId: string, options?: ShuAllocationQueryOptions): Promise<ShuAllocationContract[]>;
+    exportShuAllocationsCsv(periodId: string): Promise<CsvExportPayload>;
+}

package/dist/contracts/ShuContract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/crossDomainPrimitives.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Bridge file for RFC 005 adoption.
+ * Source of truth remains in `ofcore`.
+ */
+export type { ScopeRef, DomainAuditActor, DomainAuditEntityRef, DomainAuditEvent, WorklistUrgency, WorklistItem, PolicyVersionedConfig, ComplianceEvaluationResult, } from 'ofcore';

package/dist/contracts/crossDomainPrimitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data/applyPendingMigrations.d.ts

@@ -0,0 +1,2 @@
+import type { DbAdapter, LoggerAdapter } from 'ofcore';
+export declare function applyPendingMigrations(adapter: DbAdapter, logger?: LoggerAdapter): Promise<void>;

package/dist/data/applyPendingMigrations.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPendingMigrations = applyPendingMigrations;
+const migrations_1 = require("./migrations");
+const noopLogger = {
+    logInfo() { },
+    logWarn() { },
+    logError() { },
+};
+async function applyPendingMigrations(adapter, logger = noopLogger) {
+    logger.logInfo('[ofcoop] starting database migration process');
+    const sorted = [...migrations_1.migrations].sort((a, b) => a.toVersion - b.toVersion);
+    const targetVersion = sorted.length > 0 ? sorted[sorted.length - 1].toVersion : 0;
+    let currentVersion = await adapter.getSchemaVersion();
+    if (currentVersion == null || currentVersion < 0)
+        currentVersion = 0;
+    if (currentVersion >= targetVersion) {
+        logger.logInfo(`[ofcoop] database already up-to-date at v${currentVersion}`);
+        return;
+    }
+    for (const migration of sorted) {
+        if (migration.toVersion > currentVersion) {
+            logger.logInfo(`[ofcoop] applying migration v${migration.toVersion}`);
+            await migration.up(adapter);
+            await adapter.setSchemaVersion(migration.toVersion);
+            currentVersion = migration.toVersion;
+        }
+    }
+    logger.logInfo(`[ofcoop] migration completed at v${currentVersion}`);
+}

package/dist/data/migrations.d.ts

@@ -0,0 +1,2 @@
+import type { Migration } from 'ofcore';
+export declare const migrations: Migration[];

package/dist/data/migrations.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrations = void 0;
+const schemas_1 = require("./schemas");
+exports.migrations = [
+    {
+        toVersion: 1,
+        up: async (adapter) => {
+            const tables = (0, schemas_1.getOfcoopTableSchemas)();
+            for (const table of tables) {
+                try {
+                    await adapter.addTable(table);
+                }
+                catch {
+                    // Adapter may throw when table already exists; migration stays idempotent.
+                }
+            }
+        },
+    },
+];

package/dist/data/repositories.d.ts

@@ -0,0 +1,114 @@
+import type { DbAdapter } from 'ofcore';
+import type { MemberContract, MemberExitInput, MemberQueryOptions, MemberWaConsentInput } from '../contracts/MemberContract';
+import type { MemberNumberPolicyContract, MemberNumberPolicyScope } from '../contracts/MemberNumberPolicyContract';
+import type { SavingLedgerContract, SavingLedgerQueryOptions } from '../contracts/SavingLedgerContract';
+import type { SavingPolicyContract, SavingPolicyScope } from '../contracts/SavingPolicyContract';
+import type { ShuAllocationContract, ShuAllocationQueryOptions, ShuPeriodContract } from '../contracts/ShuContract';
+import type { ShuConfigContract, ShuConfigQueryOptions, ShuConfigScope } from '../contracts/ShuConfigContract';
+interface MemberExitStateRow {
+    id: string;
+    stage: 'requested' | 'settled' | 'canceled';
+    reason?: string | null;
+    requestedBy?: string | null;
+    referenceId?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+interface MemberWaConsentRow {
+    id: string;
+    granted: boolean;
+    source?: string | null;
+    note?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export declare class MemberRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    create(row: MemberContract): Promise<MemberContract>;
+    update(id: string, updates: Partial<MemberContract>): Promise<MemberContract>;
+    getById(id: string): Promise<MemberContract | null>;
+    list(options?: MemberQueryOptions): Promise<MemberContract[]>;
+}
+export declare class MemberWaConsentRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    set(memberId: string, consent: MemberWaConsentInput): Promise<MemberWaConsentRow>;
+    get(memberId: string): Promise<MemberWaConsentRow | null>;
+}
+export declare class MemberExitStateRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    set(memberId: string, stage: MemberExitStateRow['stage'], payload: MemberExitInput): Promise<MemberExitStateRow>;
+    get(memberId: string): Promise<MemberExitStateRow | null>;
+}
+export declare class MemberNumberPolicyRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    upsert(policy: MemberNumberPolicyContract): Promise<MemberNumberPolicyContract>;
+    getActive(scope: MemberNumberPolicyScope): Promise<MemberNumberPolicyContract | null>;
+    list(scope: MemberNumberPolicyScope): Promise<MemberNumberPolicyContract[]>;
+}
+export declare class SavingPolicyRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    upsert(policy: SavingPolicyContract): Promise<SavingPolicyContract>;
+    getActive(scope: SavingPolicyScope): Promise<SavingPolicyContract | null>;
+    list(scope: SavingPolicyScope): Promise<SavingPolicyContract[]>;
+}
+export declare class SavingLedgerRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    create(row: SavingLedgerContract): Promise<SavingLedgerContract>;
+    listByMember(memberId: string, options?: SavingLedgerQueryOptions): Promise<SavingLedgerContract[]>;
+    listAll(options?: SavingLedgerQueryOptions): Promise<SavingLedgerContract[]>;
+    findByReference(input: {
+        memberId: string;
+        savingType: SavingLedgerContract['savingType'];
+        entryType: SavingLedgerContract['entryType'];
+        referenceType: string;
+        referenceId: string;
+        tenantId?: string | null;
+        branchId?: string | null;
+    }): Promise<SavingLedgerContract | null>;
+}
+export declare class ShuConfigRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    upsert(config: ShuConfigContract): Promise<ShuConfigContract>;
+    getActive(scope: ShuConfigScope): Promise<ShuConfigContract | null>;
+    list(scope: ShuConfigScope, options?: ShuConfigQueryOptions): Promise<ShuConfigContract[]>;
+}
+export declare class ShuPeriodRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    create(period: ShuPeriodContract): Promise<ShuPeriodContract>;
+    update(id: string, updates: Partial<ShuPeriodContract>): Promise<ShuPeriodContract>;
+    getById(id: string): Promise<ShuPeriodContract | null>;
+    list(options?: {
+        includeDeleted?: boolean;
+        tenantId?: string | null;
+        branchId?: string | null;
+    }): Promise<ShuPeriodContract[]>;
+}
+export declare class ShuAllocationRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    createMany(rows: ShuAllocationContract[]): Promise<ShuAllocationContract[]>;
+    listByPeriod(periodId: string, options?: ShuAllocationQueryOptions): Promise<ShuAllocationContract[]>;
+}
+export interface OfcoopRepositories {
+    memberRepository: MemberRepository;
+    memberWaConsentRepository: MemberWaConsentRepository;
+    memberExitStateRepository: MemberExitStateRepository;
+    memberNumberPolicyRepository: MemberNumberPolicyRepository;
+    savingPolicyRepository: SavingPolicyRepository;
+    savingLedgerRepository: SavingLedgerRepository;
+    shuConfigRepository: ShuConfigRepository;
+    shuPeriodRepository: ShuPeriodRepository;
+    shuAllocationRepository: ShuAllocationRepository;
+}
+export declare function createOfcoopRepositories(db: DbAdapter): OfcoopRepositories;
+export type { MemberExitStateRow, MemberWaConsentRow };

package/dist/data/repositories.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShuAllocationRepository = exports.ShuPeriodRepository = exports.ShuConfigRepository = exports.SavingLedgerRepository = exports.SavingPolicyRepository = exports.MemberNumberPolicyRepository = exports.MemberExitStateRepository = exports.MemberWaConsentRepository = exports.MemberRepository = void 0;
+exports.createOfcoopRepositories = createOfcoopRepositories;
+const schemas_1 = require("./schemas");
+function nowIso() {
+    return new Date().toISOString();
+}
+function isEffectiveOn(dateIso, refIso) {
+    return new Date(dateIso).getTime() <= new Date(refIso).getTime();
+}
+function toAnd(filters) {
+    if (filters.length === 0)
+        return undefined;
+    if (filters.length === 1)
+        return filters[0];
+    return { and: filters };
+}
+class MemberRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async create(row) {
+        return this.db.create(schemas_1.OFCOOP_TABLES.members, row);
+    }
+    async update(id, updates) {
+        return this.db.update(schemas_1.OFCOOP_TABLES.members, id, updates);
+    }
+    async getById(id) {
+        return this.db.get(schemas_1.OFCOOP_TABLES.members, id);
+    }
+    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_TABLES.members, {
+            filters: toAnd(filters),
+            sort: [{ field: 'lastModified', direction: 'desc' }],
+        });
+    }
+}
+exports.MemberRepository = MemberRepository;
+class MemberWaConsentRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async set(memberId, consent) {
+        const current = await this.get(memberId);
+        const payload = {
+            id: memberId,
+            granted: consent.granted,
+            source: consent.source ?? null,
+            note: consent.note ?? null,
+            version: (current?.version ?? 0) + 1,
+            lastModified: nowIso(),
+            deleted: false,
+        };
+        if (current) {
+            return this.db.update(schemas_1.OFCOOP_TABLES.memberWaConsent, memberId, payload);
+        }
+        return this.db.create(schemas_1.OFCOOP_TABLES.memberWaConsent, payload);
+    }
+    async get(memberId) {
+        return this.db.get(schemas_1.OFCOOP_TABLES.memberWaConsent, memberId);
+    }
+}
+exports.MemberWaConsentRepository = MemberWaConsentRepository;
+class MemberExitStateRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async set(memberId, stage, payload) {
+        const current = await this.get(memberId);
+        const next = {
+            id: memberId,
+            stage,
+            reason: payload.reason ?? null,
+            requestedBy: payload.requestedBy ?? null,
+            referenceId: payload.referenceId ?? null,
+            version: (current?.version ?? 0) + 1,
+            lastModified: nowIso(),
+            deleted: false,
+        };
+        if (current) {
+            return this.db.update(schemas_1.OFCOOP_TABLES.memberExitState, memberId, next);
+        }
+        return this.db.create(schemas_1.OFCOOP_TABLES.memberExitState, next);
+    }
+    async get(memberId) {
+        return this.db.get(schemas_1.OFCOOP_TABLES.memberExitState, memberId);
+    }
+}
+exports.MemberExitStateRepository = MemberExitStateRepository;
+class MemberNumberPolicyRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async upsert(policy) {
+        const existing = await this.db.get(schemas_1.OFCOOP_TABLES.memberNumberPolicies, policy.id);
+        if (existing) {
+            return this.db.update(schemas_1.OFCOOP_TABLES.memberNumberPolicies, policy.id, policy);
+        }
+        return this.db.create(schemas_1.OFCOOP_TABLES.memberNumberPolicies, policy);
+    }
+    async getActive(scope) {
+        const now = nowIso();
+        const rows = await this.list(scope);
+        return rows
+            .filter((row) => isEffectiveOn(row.effectiveDate, now))
+            .sort((a, b) => b.effectiveDate.localeCompare(a.effectiveDate))[0] ?? null;
+    }
+    async list(scope) {
+        return this.db.query(schemas_1.OFCOOP_TABLES.memberNumberPolicies, {
+            filters: {
+                and: [
+                    { deleted: false },
+                    { koperasiId: scope.koperasiId },
+                    { tenantId: scope.tenantId },
+                    { branchId: scope.branchId ?? null },
+                ],
+            },
+            sort: [{ field: 'effectiveDate', direction: 'desc' }],
+        });
+    }
+}
+exports.MemberNumberPolicyRepository = MemberNumberPolicyRepository;
+class SavingPolicyRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async upsert(policy) {
+        const existing = await this.db.get(schemas_1.OFCOOP_TABLES.savingPolicies, policy.id);
+        if (existing) {
+            return this.db.update(schemas_1.OFCOOP_TABLES.savingPolicies, policy.id, policy);
+        }
+        return this.db.create(schemas_1.OFCOOP_TABLES.savingPolicies, policy);
+    }
+    async getActive(scope) {
+        const now = nowIso();
+        const rows = await this.list(scope);
+        return rows
+            .filter((row) => isEffectiveOn(row.effectiveDate, now))
+            .sort((a, b) => b.effectiveDate.localeCompare(a.effectiveDate))[0] ?? null;
+    }
+    async list(scope) {
+        return this.db.query(schemas_1.OFCOOP_TABLES.savingPolicies, {
+            filters: {
+                and: [
+                    { deleted: false },
+                    { koperasiId: scope.koperasiId },
+                    { tenantId: scope.tenantId },
+                    { branchId: scope.branchId ?? null },
+                ],
+            },
+            sort: [{ field: 'effectiveDate', direction: 'desc' }],
+        });
+    }
+}
+exports.SavingPolicyRepository = SavingPolicyRepository;
+class SavingLedgerRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async create(row) {
+        return this.db.create(schemas_1.OFCOOP_TABLES.savingEntries, row);
+    }
+    async listByMember(memberId, options) {
+        const filters = [{ memberId }];
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        if (options?.dateFrom)
+            filters.push({ field: 'transactionDate', operator: '>=', value: options.dateFrom });
+        if (options?.dateTo)
+            filters.push({ field: 'transactionDate', operator: '<=', value: options.dateTo });
+        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_TABLES.savingEntries, {
+            filters: toAnd(filters),
+            sort: [{ field: 'transactionDate', direction: 'desc' }],
+        });
+    }
+    async listAll(options) {
+        const filters = [];
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        if (options?.dateFrom)
+            filters.push({ field: 'transactionDate', operator: '>=', value: options.dateFrom });
+        if (options?.dateTo)
+            filters.push({ field: 'transactionDate', operator: '<=', value: options.dateTo });
+        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_TABLES.savingEntries, {
+            filters: toAnd(filters),
+            sort: [{ field: 'transactionDate', direction: 'desc' }],
+        });
+    }
+    async findByReference(input) {
+        const filters = [
+            { deleted: false },
+            { memberId: input.memberId },
+            { savingType: input.savingType },
+            { entryType: input.entryType },
+            { referenceType: input.referenceType },
+            { referenceId: input.referenceId },
+        ];
+        if (input.tenantId !== undefined)
+            filters.push({ tenantId: input.tenantId ?? null });
+        if (input.branchId !== undefined)
+            filters.push({ branchId: input.branchId ?? null });
+        const rows = await this.db.query(schemas_1.OFCOOP_TABLES.savingEntries, {
+            filters: toAnd(filters),
+            sort: [{ field: 'lastModified', direction: 'desc' }],
+            limit: 1,
+        });
+        return rows[0] ?? null;
+    }
+}
+exports.SavingLedgerRepository = SavingLedgerRepository;
+class ShuConfigRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async upsert(config) {
+        const existing = await this.db.get(schemas_1.OFCOOP_TABLES.shuConfigs, config.id);
+        if (existing) {
+            return this.db.update(schemas_1.OFCOOP_TABLES.shuConfigs, config.id, config);
+        }
+        return this.db.create(schemas_1.OFCOOP_TABLES.shuConfigs, config);
+    }
+    async getActive(scope) {
+        const now = nowIso();
+        const rows = await this.list(scope);
+        return rows
+            .filter((row) => isEffectiveOn(row.effectiveDate, now))
+            .sort((a, b) => b.effectiveDate.localeCompare(a.effectiveDate))[0] ?? null;
+    }
+    async list(scope, options) {
+        const filters = [
+            { koperasiId: scope.koperasiId },
+            { tenantId: scope.tenantId },
+            { branchId: scope.branchId ?? null },
+        ];
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        return this.db.query(schemas_1.OFCOOP_TABLES.shuConfigs, {
+            filters: toAnd(filters),
+            sort: [{ field: 'effectiveDate', direction: 'desc' }],
+        });
+    }
+}
+exports.ShuConfigRepository = ShuConfigRepository;
+class ShuPeriodRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async create(period) {
+        return this.db.create(schemas_1.OFCOOP_TABLES.shuPeriods, period);
+    }
+    async update(id, updates) {
+        return this.db.update(schemas_1.OFCOOP_TABLES.shuPeriods, id, updates);
+    }
+    async getById(id) {
+        return this.db.get(schemas_1.OFCOOP_TABLES.shuPeriods, id);
+    }
+    async list(options) {
+        const filters = [];
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        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_TABLES.shuPeriods, {
+            filters: toAnd(filters),
+            sort: [{ field: 'lastModified', direction: 'desc' }],
+        });
+    }
+}
+exports.ShuPeriodRepository = ShuPeriodRepository;
+class ShuAllocationRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async createMany(rows) {
+        if (rows.length === 0)
+            return [];
+        return this.db.bulkCreate(schemas_1.OFCOOP_TABLES.shuAllocations, rows);
+    }
+    async listByPeriod(periodId, options) {
+        const filters = [{ shuPeriodId: periodId }];
+        if (!options?.includeDeleted)
+            filters.push({ deleted: false });
+        if (options?.memberId)
+            filters.push({ memberId: options.memberId });
+        return this.db.query(schemas_1.OFCOOP_TABLES.shuAllocations, {
+            filters: toAnd(filters),
+            sort: [{ field: 'lastModified', direction: 'desc' }],
+        });
+    }
+}
+exports.ShuAllocationRepository = ShuAllocationRepository;
+function createOfcoopRepositories(db) {
+    return {
+        memberRepository: new MemberRepository(db),
+        memberWaConsentRepository: new MemberWaConsentRepository(db),
+        memberExitStateRepository: new MemberExitStateRepository(db),
+        memberNumberPolicyRepository: new MemberNumberPolicyRepository(db),
+        savingPolicyRepository: new SavingPolicyRepository(db),
+        savingLedgerRepository: new SavingLedgerRepository(db),
+        shuConfigRepository: new ShuConfigRepository(db),
+        shuPeriodRepository: new ShuPeriodRepository(db),
+        shuAllocationRepository: new ShuAllocationRepository(db),
+    };
+}

package/dist/data/schemas.d.ts

@@ -0,0 +1,14 @@
+import type { DbSchema, TableSchema } from 'ofcore';
+export declare const OFCOOP_TABLES: {
+    readonly members: "ofcoop_members";
+    readonly memberWaConsent: "ofcoop_member_wa_consent";
+    readonly memberExitState: "ofcoop_member_exit_state";
+    readonly memberNumberPolicies: "ofcoop_member_number_policies";
+    readonly savingPolicies: "ofcoop_saving_policies";
+    readonly savingEntries: "ofcoop_saving_entries";
+    readonly shuConfigs: "ofcoop_shu_configs";
+    readonly shuPeriods: "ofcoop_shu_periods";
+    readonly shuAllocations: "ofcoop_shu_allocations";
+};
+export declare const ofcoopSchema: DbSchema;
+export declare function getOfcoopTableSchemas(): TableSchema[];