biz-a-cli 2.3.80-15419 → 2.3.80

package/engine/attachments/store.js

@@ -1,195 +0,0 @@
-/*
- * Doc 8 M6 (D11) — the PLATFORM attachment store: files belonging to a record, kept in the tenant database
- * (SYS$ATTACHMENT, PostgreSQL; migrations/postgres/1790700000000__attachment.sql).
- *
- * App-agnostic. A file belongs to an OWNER `{ type, id }` (e.g. `fina.jv` / `140`), and every statement names it, so one
- * record's files are never reached through another's. WHO may list, add or remove is the caller's rule (for FINA
- * documents: engine/fina/attachments.js); the limits are the caller's too (`{ maxFiles, maxFileMb, extensions }`).
- *
- * Files travel in CHUNKS of at most 1 MiB, base64 in JSON: begin (name, size, the limits) → append … → finish (the
- * stored length must be the declared size). One request per chunk keeps each call small on a phone connection; the
- * engine path gives a socket call 15 s. Reads come back in the same chunks.
- *
- * ⚠️ NEVER LIVE CONTENT. The extension decides the stored type, never the browser, and only PDFs and raster images are
- * typed as themselves: anything else (svg, html included) is application/octet-stream, so a browser asked to open it
- * downloads it instead of running its script in the app's origin (`canOpen`).
- */
-
-export const CHUNK_BYTES = 1024 * 1024;
-const TABLE = "SYS$ATTACHMENT";
-const STALE = "interval '1 hour'";
-
-const TYPES = { pdf: "application/pdf", png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp" };
-const OPENABLE = new Set(Object.values(TYPES));
-
-export const extensionOf = (name) => {
-	const m = /\.([A-Za-z0-9]{1,10})$/.exec(String(name ?? ""));
-	return m ? m[1].toLowerCase() : null;
-};
-export const mimeOf = (name) => TYPES[extensionOf(name)] ?? "application/octet-stream";
-export const canOpen = (mimeType) => OPENABLE.has(String(mimeType ?? ""));
-
-const fail = (code, message) => Object.assign(new Error(message), { code });
-const text = (value) => `'${String(value).replace(/'/g, "''")}'`;
-const userOf = (userId) => (Number.isInteger(userId) ? String(userId) : "NULL");
-
-const ownerOf = (owner) => {
-	const type = owner?.type;
-	const id = owner?.id === undefined || owner?.id === null ? "" : String(owner.id);
-	if (typeof type !== "string" || !/^[a-z0-9_.]{1,64}$/.test(type) || !/^[A-Za-z0-9_-]{1,64}$/.test(id)) {
-		throw fail("INVALID", "An attachment belongs to a record: an owner type and id of letters, digits, '.', '_' or '-'.");
-	}
-	return `OWNER_TYPE = ${text(type)} AND OWNER_ID = ${text(id)}`;
-};
-
-const idOf = (value) => {
-	const id = Number(value);
-	if (!Number.isInteger(id) || id <= 0) throw fail("INVALID", `An attachment id is a positive whole number, not ${JSON.stringify(value)}.`);
-	return id;
-};
-
-/* The name as a person gave it, without a path or control characters; at most 255 characters, the extension kept. */
-const cleanName = (raw) => {
-	const base = String(raw ?? "")
-		.split(/[\\/]/)
-		.pop()
-		.replace(/[\u0000-\u001f\u007f]/g, "")
-		.trim();
-	if (!base || base === "." || base === "..") throw fail("INVALID", "A file needs a name.");
-	if (base.length <= 255) return base;
-	const ext = extensionOf(base);
-	return ext ? base.slice(0, 254 - ext.length) + "." + ext : base.slice(0, 255);
-};
-
-const limitsOf = (limits) => ({
-	maxFiles: Number.isInteger(limits?.maxFiles) ? limits.maxFiles : 0,
-	maxBytes: Math.floor(Number(limits?.maxFileMb ?? 0) * 1024 * 1024),
-	extensions: (Array.isArray(limits?.extensions) ? limits.extensions : []).map((e) => String(e).toLowerCase()),
-});
-
-const decodedLength = (b64) => (b64.length / 4) * 3 - (b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0);
-
-export const createAttachmentStore = ({ exec }) => {
-	const count = async (where) => Number((await exec(`SELECT COUNT(*) AS N FROM ${TABLE} WHERE ${where}`))?.[0]?.n ?? 0);
-
-	return {
-		/* The record's files (READY only), oldest first. */
-		list: async ({ owner }) => {
-			const where = ownerOf(owner);
-			const rows = (await exec(`SELECT ID, FILE_NAME, MIME_TYPE, SIZE_BYTES, CREATED_BY, CREATED_AT FROM ${TABLE} WHERE ${where} AND STATUS = 'READY' ORDER BY ID`)) ?? [];
-			return rows.map((r) => ({
-				id: Number(r.id),
-				fileName: r.file_name,
-				mimeType: r.mime_type,
-				size: Number(r.size_bytes),
-				createdBy: r.created_by === null || r.created_by === undefined ? null : Number(r.created_by),
-				createdAt: r.created_at,
-			}));
-		},
-
-		/* A new file, within the limits; answers the id its chunks go to. */
-		begin: async ({ owner, fileName, size, userId }, limits) => {
-			const where = ownerOf(owner);
-			const name = cleanName(fileName);
-			const { maxFiles, maxBytes, extensions } = limitsOf(limits);
-			const ext = extensionOf(name);
-			if (!ext || !extensions.includes(ext)) {
-				throw fail("ATTACHMENT_RULE", `${name}: this type of file is not allowed (allowed: ${extensions.join(", ") || "none"}).`);
-			}
-			const bytes = Number(size);
-			if (!Number.isInteger(bytes) || bytes <= 0) throw fail("ATTACHMENT_RULE", `${name} is empty.`);
-			if (bytes > maxBytes) throw fail("ATTACHMENT_RULE", `${name} is larger than ${limits?.maxFileMb} MB.`);
-			/* An upload left behind (the browser closed mid-way) is cleared before the count. */
-			await exec(`DELETE FROM ${TABLE} WHERE ${where} AND STATUS = 'UPLOADING' AND CREATED_AT < now() - ${STALE}`);
-			if ((await count(where)) + 1 > maxFiles) throw fail("ATTACHMENT_RULE", `At most ${maxFiles} files per document.`);
-			const rows = await exec(
-				`INSERT INTO ${TABLE} (OWNER_TYPE, OWNER_ID, FILE_NAME, MIME_TYPE, SIZE_BYTES, CONTENT, STATUS, CREATED_BY) ` +
-					`VALUES (${text(owner.type)}, ${text(String(owner.id))}, ${text(name)}, ${text(mimeOf(name))}, ${bytes}, '', 'UPLOADING', ${userOf(userId)}) RETURNING ID`,
-			);
-			return { id: Number(rows?.[0]?.id) };
-		},
-
-		/* One chunk (base64, ≤ 1 MiB) onto an open upload of that owner; never past the declared size. */
-		append: async ({ owner, id, chunk }) => {
-			const where = ownerOf(owner);
-			const target = idOf(id);
-			const b64 = typeof chunk === "string" ? chunk : "";
-			if (!/^[A-Za-z0-9+/]*={0,2}$/.test(b64) || b64.length % 4 !== 0) throw fail("INVALID", "A chunk is base64.");
-			const bytes = decodedLength(b64);
-			if (bytes > CHUNK_BYTES) throw fail("ATTACHMENT_RULE", "A chunk is at most 1 MiB.");
-			const rows = await exec(
-				`UPDATE ${TABLE} SET CONTENT = CONTENT || decode('${b64}', 'base64') WHERE ID = ${target} AND ${where} ` +
-					`AND STATUS = 'UPLOADING' AND octet_length(CONTENT) + ${bytes} <= SIZE_BYTES RETURNING octet_length(CONTENT) AS STORED`,
-			);
-			if (!rows || rows.length === 0) throw fail("ATTACHMENT_RULE", "This upload is not open, or it is longer than its declared size.");
-			return { stored: Number(rows[0].stored) };
-		},
-
-		/* The upload complete: READY when every byte arrived; otherwise it is dropped. */
-		finish: async ({ owner, id }) => {
-			const where = ownerOf(owner);
-			const target = idOf(id);
-			const rows = await exec(
-				`UPDATE ${TABLE} SET STATUS = 'READY' WHERE ID = ${target} AND ${where} AND STATUS = 'UPLOADING' ` +
-					`AND octet_length(CONTENT) = SIZE_BYTES RETURNING ID, FILE_NAME, MIME_TYPE, SIZE_BYTES`,
-			);
-			if (!rows || rows.length === 0) {
-				await exec(`DELETE FROM ${TABLE} WHERE ID = ${target} AND ${where} AND STATUS = 'UPLOADING'`);
-				throw fail("ATTACHMENT_RULE", "The file did not arrive whole; send it again.");
-			}
-			const r = rows[0];
-			return { id: Number(r.id), fileName: r.file_name, mimeType: r.mime_type, size: Number(r.size_bytes) };
-		},
-
-		/* One chunk of a READY file of that owner, from `offset`. */
-		read: async ({ owner, id, offset = 0 }) => {
-			const where = ownerOf(owner);
-			const target = idOf(id);
-			const from = Number(offset);
-			if (!Number.isInteger(from) || from < 0) throw fail("INVALID", "The offset is a whole number from 0.");
-			const rows = await exec(
-				`SELECT translate(encode(substring(CONTENT from ${from + 1} for ${CHUNK_BYTES}), 'base64'), E'\\n', '') AS DATA, SIZE_BYTES, FILE_NAME, MIME_TYPE ` +
-					`FROM ${TABLE} WHERE ID = ${target} AND ${where} AND STATUS = 'READY'`,
-			);
-			if (!rows || rows.length === 0) throw fail("ATTACHMENT_NOT_FOUND", `Attachment ${target} was not found.`);
-			const r = rows[0];
-			const data = String(r.data ?? "");
-			const size = Number(r.size_bytes);
-			return { id: target, offset: from, size, done: from + decodedLength(data) >= size, data, fileName: r.file_name, mimeType: r.mime_type };
-		},
-
-		/* The ids named, of that owner only. */
-		remove: async ({ owner, ids }) => {
-			const where = ownerOf(owner);
-			const wanted = (Array.isArray(ids) ? ids : []).map(idOf);
-			if (wanted.length === 0) return { removed: [] };
-			const rows = (await exec(`DELETE FROM ${TABLE} WHERE ${where} AND ID IN (${wanted.join(", ")}) RETURNING ID`)) ?? [];
-			return { removed: rows.map((r) => Number(r.id)) };
-		},
-
-		/* Salin (L-11): the files named, as NEW files of another owner, within its count. */
-		copy: async ({ from, to, ids, userId }, limits) => {
-			const source = ownerOf(from);
-			const target = ownerOf(to);
-			const wanted = [...new Set((Array.isArray(ids) ? ids : []).map(idOf))];
-			if (wanted.length === 0) return { copied: [] };
-			if ((await count(`${source} AND STATUS = 'READY' AND ID IN (${wanted.join(", ")})`)) !== wanted.length) {
-				throw fail("ATTACHMENT_NOT_FOUND", "A file to copy is not among the source's attachments.");
-			}
-			const { maxFiles } = limitsOf(limits);
-			if ((await count(target)) + wanted.length > maxFiles) throw fail("ATTACHMENT_RULE", `At most ${maxFiles} files per document.`);
-			const rows =
-				(await exec(
-					`INSERT INTO ${TABLE} (OWNER_TYPE, OWNER_ID, FILE_NAME, MIME_TYPE, SIZE_BYTES, CONTENT, STATUS, CREATED_BY) ` +
-						`SELECT ${text(to.type)}, ${text(String(to.id))}, FILE_NAME, MIME_TYPE, SIZE_BYTES, CONTENT, 'READY', ${userOf(userId)} ` +
-						`FROM ${TABLE} WHERE ${source} AND STATUS = 'READY' AND ID IN (${wanted.join(", ")}) RETURNING ID`,
-				)) ?? [];
-			return { copied: rows.map((r) => Number(r.id)) };
-		},
-
-		/* Every file of a record that is gone. */
-		removeOwner: async ({ owner }) => {
-			await exec(`DELETE FROM ${TABLE} WHERE ${ownerOf(owner)}`);
-		},
-	};
-};

package/engine/domain/domainRegistration.js

@@ -1,65 +0,0 @@
-/*
- * Registering domains in the tenant's APPLICATION_CONFIG — the one rule shared by the writers that ADD to it without
- * owning it: Control Center's publish (engine/cc/publish.js) and `biza add --register` (bin/app.js, Doc 8).
- *
- * `domains[key].source = "<name>@<version>"`, where the key is the entry whose source already names that domain (an
- * application may key a domain under another name), else the domain's own name (ruling 2026-09-30). Every other field
- * of the entry, and every other domain, is kept.
- *
- * ⚠️ WHY THIS IS NOT A WHOLESALE WRITE. APPLICATION_CONFIG has several writers, and readers take the newest row. A
- * writer that replaces it drops what the others added — their domains (and with them the entity configs the hub
- * loads) and their menus.
- */
-import { mergeDomainNavigation } from "./domainNavigation.js";
-
-const SEMVER = /^(\d+)\.(\d+)\.(\d+)$/;
-const isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
-
-export const bumpPatch = (version) => {
-	const m = SEMVER.exec(String(version ?? ""));
-	return m ? `${m[1]}.${m[2]}.${Number(m[3]) + 1}` : "0.1.0";
-};
-
-/* A domain's source "name@version" → name. */
-export const sourceName = (source) => String(source ?? "").split("@")[0];
-
-/* `versions`: a Map or a plain object, domain name → version. Answers a new config; the input is left as it was. */
-export const registerDomainVersions = (applicationConfig, versions) => {
-	const app = JSON.parse(JSON.stringify(applicationConfig ?? {}));
-	app.domains = isObj(app.domains) ? app.domains : {};
-	const entries = versions instanceof Map ? [...versions] : Object.entries(versions ?? {});
-	for (const [name, version] of entries) {
-		const key = Object.keys(app.domains).find((k) => sourceName(app.domains[k]?.source) === name) ?? name;
-		app.domains[key] = { ...(app.domains[key] ?? {}), source: `${name}@${version}` };
-	}
-	return app;
-};
-
-/*
- * Doc 8 (2026-10-10) — the inverse: take domains OUT of an application config (`biza unregister`), as when a domain
- * moves from the host into its own application. `names`: domain names, matched against the entry key or its source.
- *
- * ⚠️ The menu leaves those domains' publishes stamped go with them (mergeDomainNavigation with no entries strips a
- * domain's leaves and the groups they emptied). A leaf whose domain is no longer registered makes the next publish
- * throw "Cannot resolve menu domain", so removing only the entry would break the host.
- *
- * Answers `{ config, removed }` (the removed entry keys); the input is left as it was.
- */
-export const unregisterDomains = (applicationConfig, names) => {
-	const app = JSON.parse(JSON.stringify(applicationConfig ?? {}));
-	const wanted = new Set((names ?? []).map((n) => String(n ?? "").trim()).filter(Boolean));
-	const domains = isObj(app.domains) ? app.domains : {};
-	const removed = Object.keys(domains).filter((key) => wanted.has(key) || wanted.has(sourceName(domains[key]?.source)));
-	if (removed.length === 0) return { config: app, removed };
-
-	let next = app;
-	for (const key of removed) {
-		/* A leaf may name its domain by key or by source name (resolveDomainKeyByReference takes either). */
-		for (const reference of new Set([key, sourceName(domains[key]?.source)])) {
-			next = { ...next, navigation: mergeDomainNavigation({ applicationConfig: next, domainKey: reference, menus: [] }) };
-		}
-		delete domains[key];
-	}
-	next.domains = domains;
-	return { config: next, removed };
-};

package/engine/fina/approval.js

@@ -1,141 +0,0 @@
-/*
- * Doc 8 M7 — the JV approval workflow FINA Cloud generates when Need Approval is on (A-02, A-03, A-04).
- *
- * ONE WAY: a submission waits (MENUNGGU) for the approver role (A-06, D13 FINA_JV_APPROVER, mapped to user groups in
- * SYS$BPM_ROLE_GROUP); SETUJUI ends it approved and its effect posts the JV to FINA (A-07); TOLAK ends it rejected (A-08).
- * Another flow (a revision loop) is the user's own work in the BPM module (A-03): a published definition that is not
- * this one is KEPT, never overwritten.
- *
- * The effects are one-line CLI scripts that hand the instance to engine/fina (`lib.fina.approval`, submission.js): the
- * posting, its rules and its user are the server's, never a script's.
- */
-import { sqlString } from "./sql.js";
-
-export const APPROVAL = Object.freeze({
-	key: "FINA_JV_APPROVAL",
-	entityType: "FINA_JV_SUBMISSION",
-	role: "FINA_JV_APPROVER",
-	waiting: "MENUNGGU",
-	approved: "DISETUJUI",
-	rejected: "DITOLAK",
-	postScript: "fina_jv_submission_post",
-	rejectScript: "fina_jv_submission_reject",
-});
-
-const role = [{ roleCode: APPROVAL.role }];
-
-export const approvalDefinition = () => ({
-	workflowKey: APPROVAL.key,
-	name: "Persetujuan Jurnal Voucher (FINA Cloud)",
-	entityType: APPROVAL.entityType,
-	description: "Generated by the FINA Cloud console when Need Approval is on (Doc 8 A-02).",
-	status: "DRAFT",
-	initialStateCode: APPROVAL.waiting,
-	states: [
-		{ stateCode: APPROVAL.waiting, label: "Menunggu persetujuan", taskEnabled: true, taskName: "Setujui Jurnal Voucher", assignmentType: "ROLE", assignmentValue: APPROVAL.role },
-		{ stateCode: APPROVAL.approved, label: "Disetujui" },
-		{ stateCode: APPROVAL.rejected, label: "Ditolak" },
-	],
-	transitions: [
-		{
-			transitionCode: "SETUJUI",
-			fromStateCode: APPROVAL.waiting,
-			toStateCode: APPROVAL.approved,
-			label: "Setujui",
-			roles: role,
-			effects: [{ effectType: "CLI_SCRIPT", eventName: APPROVAL.postScript }],
-		},
-		{
-			transitionCode: "TOLAK",
-			fromStateCode: APPROVAL.waiting,
-			toStateCode: APPROVAL.rejected,
-			label: "Tolak",
-			roles: role,
-			effects: [{ effectType: "CLI_SCRIPT", eventName: APPROVAL.rejectScript }],
-		},
-	],
-});
-
-const script = (call) => `(function (lib) { return { functions: { onInit: async function (scriptData) { return ${call}(scriptData); } } }; })`;
-
-export const approvalScripts = () => ({
-	[APPROVAL.postScript]: script("lib.fina.approval.post"),
-	[APPROVAL.rejectScript]: script("lib.fina.approval.reject"),
-});
-
-/* What makes two definitions the same workflow (the version, status and description aside). */
-const shape = (def) => JSON.stringify({ entityType: def?.entityType, initialStateCode: def?.initialStateCode, states: def?.states, transitions: def?.transitions });
-
-/*
- * The console Publish with Need Approval on (route fina/setup/approval). `deps`: exec / execStatements on this hub's
- * database, and the BPM engine's `save` / `publish` (engine/bpm/workflow.js).
- *   - The scripts are always refreshed (an upsert by name).
- *   - No published definition yet → this one, saved as a draft and published.
- *   - The same one published → nothing (no new version on every Publish).
- *   - Another one published (edited in the BPM module, A-03) → kept.
- */
-export const publishApproval = async ({ exec, execStatements, save, publish, userId }) => {
-	const statements = [];
-	for (const [name, body] of Object.entries(approvalScripts())) {
-		statements.push(`UPDATE SYS$CLI_SCRIPT SET SCRIPT = ${sqlString(body)} WHERE SCRIPT_NAME = ${sqlString(name)}`);
-		statements.push(
-			`INSERT INTO SYS$CLI_SCRIPT (SCRIPT_NAME, SCRIPT) SELECT ${sqlString(name)}, ${sqlString(body)} ` +
-				`WHERE NOT EXISTS (SELECT 1 FROM SYS$CLI_SCRIPT WHERE SCRIPT_NAME = ${sqlString(name)})`,
-		);
-	}
-	await execStatements(statements);
-
-	const latest =
-		(await exec(`SELECT DEFINITION_JSON FROM SYS$BPM_WORKFLOW_DEF WHERE WORKFLOW_KEY = ${sqlString(APPROVAL.key)} AND STATUS = 'PUBLISHED' ORDER BY VERSION DESC LIMIT 1`)) ?? [];
-	const definition = approvalDefinition();
-	if (latest.length > 0) {
-		let published = null;
-		try {
-			published = JSON.parse(latest[0].definition_json);
-		} catch {
-			published = null;
-		}
-		return shape(published) === shape(definition) ? { published: false } : { published: false, kept: true };
-	}
-
-	const rawJsonString = JSON.stringify(definition);
-	const saved = await save({ id: null, userId, rawJsonString });
-	const row = Array.isArray(saved) ? saved[0] : saved;
-	const id = row?.ID ?? row?.id;
-	if (id === undefined || id === null) throw new Error("The approval workflow was not saved: the BPM engine answered no id.");
-	await publish({ id, userId, rawJsonString });
-	return { published: true };
-};
-
-const instanceIdOf = (value) => {
-	const id = Number(value);
-	if (!Number.isInteger(id) || id <= 0 || !/^\d+$/.test(String(value).trim())) throw new Error(`A workflow instance id is a positive whole number, not ${JSON.stringify(value)}.`);
-	return id;
-};
-
-/*
- * What submission.js needs of the BPM engine, on this hub's database (`dbIndex`): reads straight from SYS$BPM_*, and
- * the runtime's own initiate / terminate (imported lazily, as bin/hubEvent.js does: it brings the worker pool).
- */
-export const createApprovalBpm = ({ exec, dbIndex, runtime = () => import("../bpm/workflow-runtime.js") }) => ({
-	published: async () =>
-		((await exec(`SELECT 1 AS N FROM SYS$BPM_WORKFLOW_DEF WHERE WORKFLOW_KEY = ${sqlString(APPROVAL.key)} AND STATUS = 'PUBLISHED' LIMIT 1`)) ?? []).length > 0,
-
-	initiate: async ({ workflowKey, entityType, entityId, userId }) => {
-		const rows = await (await runtime()).initiate({ workflowKey, entityType, entityId, userId, apiConfig: { dbIndex } });
-		const instanceId = Number(rows?.[0]?.ID ?? rows?.[0]?.id);
-		if (!Number.isInteger(instanceId) || instanceId <= 0) throw new Error("The BPM engine answered no instance id.");
-		return { instanceId };
-	},
-
-	terminate: async ({ instanceId, userId }) => (await runtime()).terminate({ instanceId: instanceIdOf(instanceId), userId, apiConfig: { dbIndex } }),
-
-	instance: async (instanceId) =>
-		((await exec(`SELECT ENTITY_TYPE, ENTITY_ID, CURRENT_STATE_CODE, STATUS FROM SYS$BPM_WF_INSTANCE WHERE ID = ${instanceIdOf(instanceId)}`)) ?? [])[0] ?? null,
-
-	decider: async (instanceId) => {
-		const row = ((await exec(`SELECT ACTOR_ID FROM SYS$BPM_STATE_HISTORY WHERE SYS$BPM_WF_INSTANCE_ID = ${instanceIdOf(instanceId)} ORDER BY ID DESC LIMIT 1`)) ?? [])[0];
-		const id = Number(row?.actor_id);
-		return row?.actor_id === null || row?.actor_id === undefined || !Number.isInteger(id) ? null : id;
-	},
-});

package/engine/fina/approvalService.js

@@ -1,59 +0,0 @@
-/*
- * Doc 8 M7 — the JV submission service with its live parts, for the routes (routes/submission.js) and for the approval
- * workflow's effects (`lib.fina`, worker/cliScriptWorker.js).
- *
- * ⚠️ An effect runs with NO principal (BPM agent → CLI-script worker): what it may do is decided here, by the
- * instance it names — a FINA_JV_SUBMISSION instance standing at DISETUJUI / DITOLAK (submission.js `post` / `reject`)
- * — and the JV is posted as the submitter, never as anyone a script names.
- */
-import { finaError } from "./errors.js";
-import { finaCloudConfig } from "./config.js";
-import { createIdentity } from "./identity.js";
-import { createSettingsStore } from "./settings.js";
-import { createFeatures } from "./features.js";
-import { createDocumentWriter } from "./documentWrite.js";
-import { createSubmissionService } from "./submission.js";
-import { createSubmissionRepo } from "./submissionRepo.js";
-import { createApprovalBpm } from "./approval.js";
-import { createAttachmentStore } from "../attachments/store.js";
-
-export const NOTICE = "FINA_JV_SUBMISSION";
-
-export const submissionServiceOf = (deps, config) => {
-	const identity = createIdentity(deps);
-	const settings = createSettingsStore(deps);
-	const features = createFeatures(deps);
-	const attachments = createAttachmentStore({ exec: deps.exec });
-	return createSubmissionService({
-		client: deps.client,
-		identity,
-		settings,
-		features,
-		repo: createSubmissionRepo({ exec: deps.exec }),
-		bpm: deps.approvalBpm ?? createApprovalBpm({ exec: deps.exec, dbIndex: config?.tenantDbIndex }),
-		attachments,
-		writer: createDocumentWriter({ client: deps.client, identity, settings, features, attachments }),
-	});
-};
-
-/*
- * `lib.fina` — `apiConfig` is the hub's (argv: --finaCloudDbindex, --dbindex, the FINA API's host). An effect's data
- * arrives wrapped `{ body, headers }`. FINA Cloud off → NOT_CONFIGURED, THROWN: the effect then shows failed in the
- * BPM module and can be retried once it is on. Every other outcome is an answer (submission.js never throws).
- */
-export const finaScriptLib = (apiConfig, { emitUsers, serviceOf } = {}) => {
-	const config = finaCloudConfig(apiConfig);
-	const service = async () => {
-		if (!config.enabled) throw finaError("NOT_CONFIGURED", "FINA Cloud is not switched on for this company (the hub runs without --finaCloudDbindex).");
-		if (serviceOf) return serviceOf(config);
-		const { createLiveFinaDeps } = await import("./live.js");
-		return submissionServiceOf(createLiveFinaDeps(config), config);
-	};
-	const run = (action) => async (scriptData) => {
-		const body = scriptData?.body && typeof scriptData.body === "object" ? scriptData.body : (scriptData ?? {});
-		const { notify, ...answer } = await (await service())[action]({ instanceId: body.instanceId });
-		if (notify?.userIds?.length > 0 && typeof emitUsers === "function") emitUsers(notify.userIds, NOTICE, notify.data);
-		return answer;
-	};
-	return { approval: { post: run("post"), reject: run("reject") } };
-};

package/engine/fina/attachments.js

@@ -1,165 +0,0 @@
-/*
- * Doc 8 M6 — a FINA document's attachments (F-34–F-37, L-11): the FINA rule in front of the platform store
- * (engine/attachments/store.js). The files live in Biz-A (SYS$ATTACHMENT), never in FINA, so FINA desktop cannot see
- * them (F-36).
- *
- * - Listing and reading: any mapped FINA user (D4: view), of a document FINA has.
- * - Adding, removing and copying onto a document: FINA's create OR edit right (Agung 2026-10-12), of a document FINA
- *   has, whose date is open: neither Biz-A-locked (C-14) nor in a closed FINA period (C-15), as for the document itself.
- * - The limits are the console's (FINA$SETTING `<document>.attachments`, F-35).
- *
- * Only a document whose descriptor says `attachments: true` has any.
- *
- * Doc 8 M7 — a JV SUBMISSION has its own (`{ submission: 'jv', id }` → owner `fina.jvsub`): read by any mapped user,
- * changed by the create or edit right only while it waits (MENUNGGU) on an open date, the JV's limits. On posting they
- * are copied to the new JV by the server (submission.js). A copy (Salin) may come from either kind: `fromOwner` names
- * the source's owner props when it is not the target's kind (a FINA JV's files onto a new submission).
- */
-import { finaError } from "./errors.js";
-import { requireRight } from "./identity.js";
-import { documentOf, documentId } from "./documents/index.js";
-import { readMaster } from "./document.js";
-import { isDateLocked, toDateOnly } from "./lock.js";
-import { checkPeriods } from "./period.js";
-
-export const ownerOf = (name, id) => ({ type: `fina.${name}`, id: String(id) });
-export const submissionOwnerOf = (id) => ({ type: "fina.jvsub", id: String(id) });
-
-export const createFinaAttachments = ({ client, identity, settings, store, submissions = null }) => {
-	const documentWithAttachments = (name) => {
-		const document = documentOf(name);
-		if (!document.attachments) throw finaError("INVALID", `A ${document.label} has no attachments in Biz-A.`);
-		return document;
-	};
-
-	const existing = async (document, id) => {
-		const master = await readMaster(client, document, id);
-		if (!master) throw finaError("DOCUMENT_NOT_FOUND", `${document.label} ${id} was not found.`);
-		return master;
-	};
-
-	/* Any mapped FINA user, of a document FINA has. */
-	const readable = async (principal, name, rawId) => {
-		const document = documentWithAttachments(name);
-		const id = documentId(rawId);
-		requireRight(await identity.resolve(principal), document.rights, null);
-		await existing(document, id);
-		return { document, owner: ownerOf(document.name, id) };
-	};
-
-	/* The create OR edit right; with `open`, also a document FINA has, on an open date, and the console limits. */
-	const changeable = async (principal, name, rawId, { open = true } = {}) => {
-		const document = documentWithAttachments(name);
-		const id = documentId(rawId);
-		const who = requireRight(await identity.resolve(principal), document.rights, null);
-		const rights = who.rights?.[document.rights] ?? {};
-		if (rights.create !== true && rights.edit !== true) {
-			throw finaError("FORBIDDEN", `Your FINA user ${who.finaUser?.name} may not change the attachments of ${document.label} records.`);
-		}
-		const owner = ownerOf(document.name, id);
-		if (!open) return { document, owner };
-		const master = await existing(document, id);
-		const config = await settings.read();
-		const date = toDateOnly(master.transdate);
-		const upTo = config?.lock?.upTo ?? null;
-		if (isDateLocked(date, upTo)) {
-			throw finaError("DATE_LOCKED", `${date} is on or before the Biz-A lock date ${toDateOnly(upTo)}: its attachments cannot be changed from Biz-A.`);
-		}
-		await checkPeriods(client, [date]);
-		return { document, owner, limits: config?.[document.name]?.attachments ?? null };
-	};
-
-	/* Doc 8 M7 — a JV submission (FINA$JV_SUBMISSION): it must exist; changed only while it waits. */
-	const submissionOf = async (name, rawId) => {
-		const document = documentWithAttachments(name);
-		if (document.name !== "jv" || !submissions) throw finaError("INVALID", `A ${document.label} has no submissions.`);
-		const id = documentId(rawId);
-		const row = await submissions.read(id);
-		if (!row) throw finaError("DOCUMENT_NOT_FOUND", `JV submission ${id} was not found.`);
-		return { document, id, row };
-	};
-
-	const submissionReadable = async (principal, name, rawId) => {
-		requireRight(await identity.resolve(principal), "jv", null);
-		const { document, id } = await submissionOf(name, rawId);
-		return { document, owner: submissionOwnerOf(id) };
-	};
-
-	const submissionChangeable = async (principal, name, rawId, { open = true } = {}) => {
-		const who = requireRight(await identity.resolve(principal), "jv", null);
-		const { document, id, row } = await submissionOf(name, rawId);
-		const rights = who.rights?.[document.rights] ?? {};
-		if (rights.create !== true && rights.edit !== true) {
-			throw finaError("FORBIDDEN", `Your FINA user ${who.finaUser?.name} may not change the attachments of ${document.label} submissions.`);
-		}
-		const owner = submissionOwnerOf(id);
-		if (!open) return { document, owner };
-		if (row.status !== "MENUNGGU") {
-			const name = row.number ?? `JV submission ${id}`;
-			throw finaError("DOCUMENT_RULE", `${name} is ${String(row.status).toLowerCase()}: its attachments are read only.`);
-		}
-		const config = await settings.read();
-		const date = toDateOnly(row.transdate);
-		const upTo = config?.lock?.upTo ?? null;
-		if (isDateLocked(date, upTo)) {
-			throw finaError("DATE_LOCKED", `${date} is on or before the Biz-A lock date ${toDateOnly(upTo)}: its attachments cannot be changed from Biz-A.`);
-		}
-		await checkPeriods(client, [date]);
-		return { document, owner, limits: config?.[document.name]?.attachments ?? null };
-	};
-
-	/* The owner props a request names: `{ submission }` or `{ document }`. */
-	const kindOf = (props) => {
-		if (!props || typeof props !== "object" || Array.isArray(props)) throw finaError("INVALID", "An attachment owner is { document } or { submission }.");
-		const isSubmission = props.submission !== undefined && props.submission !== null && props.submission !== "";
-		return isSubmission ? { name: props.submission, readable: submissionReadable, changeable: submissionChangeable } : { name: props.document, readable, changeable };
-	};
-	const toRead = (principal, props, id) => {
-		const kind = kindOf(props);
-		return kind.readable(principal, kind.name, id);
-	};
-	const toChange = (principal, props, id, options) => {
-		const kind = kindOf(props);
-		return kind.changeable(principal, kind.name, id, options);
-	};
-
-	return {
-		list: async (principal, request = {}) => {
-			const { owner } = await toRead(principal, request, request.id);
-			return store.list({ owner });
-		},
-
-		read: async (principal, request = {}) => {
-			const { owner } = await toRead(principal, request, request.id);
-			return store.read({ owner, id: request.attachmentId, offset: request.offset });
-		},
-
-		begin: async (principal, request = {}) => {
-			const { owner, limits } = await toChange(principal, request, request.id);
-			return store.begin({ owner, fileName: request.fileName, size: request.size, userId: principal?.userId }, limits);
-		},
-
-		/* A chunk needs only the right: its upload was opened by `begin`, which checked the record and its date. */
-		append: async (principal, request = {}) => {
-			const { owner } = await toChange(principal, request, request.id, { open: false });
-			return store.append({ owner, id: request.uploadId, chunk: request.chunk });
-		},
-
-		finish: async (principal, request = {}) => {
-			const { owner } = await toChange(principal, request, request.id);
-			return store.finish({ owner, id: request.uploadId });
-		},
-
-		remove: async (principal, request = {}) => {
-			const { owner } = await toChange(principal, request, request.id);
-			return store.remove({ owner, ids: request.ids });
-		},
-
-		/* Salin: `from` of `fromOwner` (the target's own kind when absent) onto `to`. */
-		copy: async (principal, request = {}) => {
-			const source = await toRead(principal, request.fromOwner ?? request, request.from);
-			const target = await toChange(principal, request, request.to);
-			return store.copy({ from: source.owner, to: target.owner, ids: request.ids, userId: principal?.userId }, target.limits);
-		},
-	};
-};