biz-a-cli 2.3.80-15419 → 2.3.80

package/engine/orm/apiRoute.js

@@ -48,16 +48,6 @@ import { buildValidUserIdSql, verifyCredential, buildPasswordUpgradeSql, buildUs
 import { resolveUserTenancy, capSessionExpiry } from "./tenantResolution.js";
 import { describeTenants } from "./tenantApi.js";
 import { translateExecuteBlock } from "./executeBlock.js";
-import { isUserApiDataset, saveUserApiDataset } from "./userApiDataset.js";
-import {
-	readUpdateImgRequest,
-	buildImgColumnTypeSql,
-	isTextColumnType,
-	buildPgUpdateImg,
-	parseImgGetPath,
-	buildPgGetImg,
-	getContentType,
-} from "./imgQuery.js";
 import zlib from "node:zlib";
 
 /* /fina/rest/<Class>/%22<endpoint>%22 — the path the client builds. */
@@ -175,36 +165,6 @@ export const parseGenIdRequest = (path) => {
 	return { generator, dbIndex: Number.isFinite(dbIndex) ? dbIndex : null };
 };
 
-/*
- * ⚠️⚠️ `img` — the BLOB write and read, which no other parser here can see.
- *
- * The client builds both paths UNQUOTED (`getUrlApi(config, 'img', false)`), so `DATASNAP_PATH`
- * never matches them:
- *
- *   write  POST /fina/rest/TOrmMethod/img            body = {dbIndex, tableName, imgCol, keyCol,
- *                                                            keyValue, img: <base64>} — the bare
- *                                                            object, no `_parameters`
- *   read   GET  /fina/rest/TOrmMethod/img/<db>/<table>/<keyCol>/<imgCol>/<'key'>[/<formatCol>]
- *
- * Unrecognised, both fell through to FINA. Returns { write: true, dbIndex, request } for a write,
- * { write: false, dbIndex, ...read } for a read, or null.
- */
-const IMG_WRITE_PATH = /\/fina\/rest\/\w+\/img\/?(?:[?#]|$)/i;
-
-export const parseImgRequest = (path, body) => {
-	const read = parseImgGetPath(path);
-	if (read) return { write: false, ...read };
-	if (!IMG_WRITE_PATH.test(String(path ?? ""))) return null;
-	try {
-		const request = readEnvelope(body);
-		if (!request || typeof request !== "object") return null;
-		const dbIndex = Number(request.dbIndex);
-		return { write: true, dbIndex: Number.isFinite(dbIndex) ? dbIndex : null, request };
-	} catch {
-		return null; // a body we cannot read is not ours; it goes to FINA untouched
-	}
-};
-
 export const parseDataSnapRequest = (path, body) => {
 	const match = DATASNAP_PATH.exec(String(path ?? ""));
 	if (!match) return null;
@@ -572,118 +532,6 @@ const requestBaseTable = (parsed) => {
 	return String(Object.keys(param.object ?? {})[0] ?? "");
 };
 
-/* The write. Answered `{success: "OK"}` — FINA's own success shape, which data.service.ts
-   handleError accepts. */
-export const IMG_ROW_NOT_FOUND_CODE = "NOT_FOUND";
-const imgWriteResponse = async (request, dbIndex, exec) => {
-	/* Every name is checked BEFORE anything runs, the column-type probe included. */
-	const fields = readUpdateImgRequest(request);
-	const [column] = (await exec(buildImgColumnTypeSql(fields), dbIndex)) ?? [];
-	const updated =
-		(await exec(buildPgUpdateImg(fields, { textColumn: isTextColumnType(column?.data_type) }), dbIndex)) ?? [];
-	/* ⚠️ FINA answers OK here too. That silence is how an item image stayed NULL with nothing shown. */
-	if (updated.length === 0) {
-		return {
-			status: 404,
-			body: {
-				error: `img: no ${fields.tableName} row has ${fields.keyCol} = ${fields.key}, so the image was not stored`,
-				code: IMG_ROW_NOT_FOUND_CODE,
-			},
-		};
-	}
-	return { status: 200, body: { success: "OK" } };
-};
-
-/* The read. ⚠️ The body is a BUFFER, not JSON: both entrances check for one and send the bytes
-   with `contentType` (finaEndpoint.js, bin/hubEvent.js). FINA's answers are kept — `image/jpeg`
-   unless a format column names the type, and an EMPTY 200 for a missing row or a NULL blob. */
-const imgReadResponse = async (read, dbIndex, exec) => {
-	const [row] = (await exec(buildPgGetImg(read), dbIndex)) ?? [];
-	/* Positional, as FINA reads Fields[0] / Fields[1]: the row's key casing is the driver's business. */
-	const [image, format] = Object.values(row ?? {});
-	const bytes =
-		image === null || image === undefined
-			? Buffer.alloc(0)
-			: Buffer.isBuffer(image)
-				? image
-				: Buffer.from(String(image), "utf8"); // a text column
-	return {
-		status: 200,
-		body: bytes,
-		contentType: read.formatCol && row ? getContentType(format) : "image/jpeg",
-	};
-};
-
-/*
- * How a failure inside the router is answered. Shared by the ORM endpoints and `img`, so a refusal
- * means the same thing whichever of them raised it.
- */
-const failureResponse = (error, dbIndex) => {
-	/* Doc 3 §6.7 — a concurrency conflict is not a server fault, and must be distinguishable from
-	   one WITHOUT parsing a message, so an application can offer reload/retry instead of showing a
-	   generic failure. */
-	if (error?.code === IN_USE_CODE) {
-		return { status: 409, body: { error: error.message, code: IN_USE_CODE } };
-	}
-	if (error?.code === CONFLICT_CODE) {
-		return { status: 409, body: { error: error.message, code: CONFLICT_CODE } };
-	}
-	/* Doc 3 §6.3 — the caller asked the ORM to manage a collection its parent does not own. A
-	   caller error, and distinguishable without parsing a message so an application can point at
-	   the screen sending it. */
-	/* Doc 3 §11 write side. 403 vs 400 says WHICH kind of problem it is: naming somebody else's
-	   tenant is an authorization failure, naming none is an under-specified request the caller can
-	   fix by sending the column. */
-	if (error?.code === CROSS_TENANT_CODE) {
-		return { status: 403, body: { error: error.message, code: CROSS_TENANT_CODE } };
-	}
-	if (error?.code === AMBIGUOUS_TENANT_CODE) {
-		return { status: 400, body: { error: error.message, code: AMBIGUOUS_TENANT_CODE } };
-	}
-	/* Request input the ORM will not put into SQL text (sqlGuard.js) - a caller error, named. */
-	if (error?.code === GRAPH_READ_KEY_REQUIRED_CODE) {
-		return { status: 400, body: { error: error.message, code: GRAPH_READ_KEY_REQUIRED_CODE } };
-	}
-	if (error?.code === INCOMPLETE_COLLECTION_CODE) {
-		return { status: 400, body: { error: error.message, code: INCOMPLETE_COLLECTION_CODE } };
-	}
-	if (error?.code === UNSAFE_SQL_CODE) {
-		return { status: 400, body: { error: error.message, code: UNSAFE_SQL_CODE } };
-	}
-	if (error?.code === SHARED_RELATIONSHIP_CODE) {
-		return { status: 400, body: { error: error.message, code: SHARED_RELATIONSHIP_CODE } };
-	}
-	/* Doc 3 §11 layer 2 — an engine-level refusal from a raw-SQL path, translated into the same
-	   vocabulary the ORM path uses. Without this it reaches the browser as a bare 500. */
-	const engineRefusal = describeRlsFailure(error);
-	if (engineRefusal) {
-		return {
-			status: engineRefusal.status,
-			body: { error: engineRefusal.message, code: engineRefusal.code },
-		};
-	}
-	/* Found live 2026-10-07: a refused save reached the user as SQL. A refusal the user can act on is named by the
-	   field's label; anything else keeps its message, never the statement — that goes to the hub log only. */
-	const refusal = describeDatabaseRefusal(error, { labelOf: (table, column) => labelFor(table, column, dbIndex) });
-	if (refusal) {
-		logger.info(`[orm] ${refusal.code}: ${error?.message ?? error}`);
-		return { status: refusal.status, body: { error: refusal.message, code: refusal.code } };
-	}
-	logger.error(`[orm] ${error?.message ?? error}`);
-	return { status: 500, body: { error: withoutStatement(error?.message ?? String(error)) } };
-};
-
-/* Doc 3 §11 — a verified caller may only name its OWN PostgreSQL tenant. */
-const tenantMismatch = (path, principal, requestedDbIndex) => {
-	logger.error(
-		`[apiRequest] refused ${path}: principal is for db ${principal.dbIndex} but the request asked for db ${requestedDbIndex}`,
-	);
-	return {
-		status: 403,
-		body: { error: "request names a different tenant than the principal", code: "TENANT_MISMATCH" },
-	};
-};
-
 export const routeApiRequest = async (
 	{ path, body },
 	/* `principal` is the VERIFIED caller (Doc 3 §11's precondition), or null while the boundary runs
@@ -911,29 +759,6 @@ export const routeApiRequest = async (
 		}
 	}
 
-	/*
-	 * ⚠️⚠️ `img` — the BLOB write and read (parseImgRequest says why nothing else sees them).
-	 *
-	 * Forwarded, a PostgreSQL tenant's image went to a FINA holding a DIFFERENT database: the write
-	 * answered OK and stored nothing, the read answered an empty image. A Firebird index really does
-	 * keep its images in FINA, so it is still declined — forwarded byte for byte.
-	 */
-	const imgRequest = parseImgRequest(path, body);
-	if (imgRequest) {
-		const imgDbIndex = imgRequest.dbIndex;
-		if (imgDbIndex === null || !isPostgresIndex(imgDbIndex)) return null;
-		if (principal && imgDbIndex !== Number(principal.dbIndex)) {
-			return tenantMismatch(path, principal, imgDbIndex);
-		}
-		try {
-			return imgRequest.write
-				? await imgWriteResponse(imgRequest.request, imgDbIndex, exec)
-				: await imgReadResponse(imgRequest, imgDbIndex, exec);
-		} catch (error) {
-			return failureResponse(error, imgDbIndex);
-		}
-	}
-
 	const parsed = parseDataSnapRequest(path, body);
 	if (!parsed) return null;
 
@@ -1021,7 +846,13 @@ export const routeApiRequest = async (
 	 */
 	if (principal && requestedDbIndex !== null && isPostgresIndex(requestedDbIndex)) {
 		if (Number(requestedDbIndex) !== Number(principal.dbIndex)) {
-			return tenantMismatch(path, principal, requestedDbIndex);
+			logger.error(
+				`[apiRequest] refused ${path}: principal is for db ${principal.dbIndex} but the request asked for db ${requestedDbIndex}`,
+			);
+			return {
+				status: 403,
+				body: { error: "request names a different tenant than the principal", code: "TENANT_MISMATCH" },
+			};
 		}
 	}
 
@@ -1103,18 +934,61 @@ export const routeApiRequest = async (
 			const rows = await execTransaction(statements, dbIndex);
 			return { status: 200, body: { data: upperCaseKeys(rows), success: "OK" } };
 		}
-		/* The admin Users screen saves through FINA's TUserApiDataset. On PostgreSQL the users are
-		   SYS$USERS, so it is answered here (userApiDataset.js); forwarded, it could only meet a FINA
-		   that is not running. Every OTHER json2fina module is a FINA accounting transaction with no
-		   PostgreSQL counterpart, so it still forwards. */
-		if (parsed.endpoint === "json2fina") {
-			if (!isUserApiDataset(parsed.param)) return null;
-			return await saveUserApiDataset(parsed.param, { exec, dbIndex, principal });
-		}
-		/* Anything else — setApp, the other json2fina modules, TMfgMethod — is not part of the ORM
-		   surface. Returning null forwards it to FINA, which is honest: those still need it. */
+		/* Anything else — genId, setApp, ExecuteSQL, TMfgMethod — is not part of the ORM surface.
+		   Returning null forwards it to FINA, which is honest: those still need it. */
 		return null;
 	} catch (error) {
-		return failureResponse(error, dbIndex);
+		/* Doc 3 §6.7 — a concurrency conflict is not a server fault, and must be distinguishable from
+		   one WITHOUT parsing a message, so an application can offer reload/retry instead of showing a
+		   generic failure. */
+		if (error?.code === IN_USE_CODE) {
+			return { status: 409, body: { error: error.message, code: IN_USE_CODE } };
+		}
+		if (error?.code === CONFLICT_CODE) {
+			return { status: 409, body: { error: error.message, code: CONFLICT_CODE } };
+		}
+		/* Doc 3 §6.3 — the caller asked the ORM to manage a collection its parent does not own. A
+		   caller error, and distinguishable without parsing a message so an application can point at
+		   the screen sending it. */
+		/* Doc 3 §11 write side. 403 vs 400 says WHICH kind of problem it is: naming somebody else's
+		   tenant is an authorization failure, naming none is an under-specified request the caller can
+		   fix by sending the column. */
+		if (error?.code === CROSS_TENANT_CODE) {
+			return { status: 403, body: { error: error.message, code: CROSS_TENANT_CODE } };
+		}
+		if (error?.code === AMBIGUOUS_TENANT_CODE) {
+			return { status: 400, body: { error: error.message, code: AMBIGUOUS_TENANT_CODE } };
+		}
+		/* Request input the ORM will not put into SQL text (sqlGuard.js) - a caller error, named. */
+		if (error?.code === GRAPH_READ_KEY_REQUIRED_CODE) {
+			return { status: 400, body: { error: error.message, code: GRAPH_READ_KEY_REQUIRED_CODE } };
+		}
+		if (error?.code === INCOMPLETE_COLLECTION_CODE) {
+			return { status: 400, body: { error: error.message, code: INCOMPLETE_COLLECTION_CODE } };
+		}
+		if (error?.code === UNSAFE_SQL_CODE) {
+			return { status: 400, body: { error: error.message, code: UNSAFE_SQL_CODE } };
+		}
+		if (error?.code === SHARED_RELATIONSHIP_CODE) {
+			return { status: 400, body: { error: error.message, code: SHARED_RELATIONSHIP_CODE } };
+		}
+		/* Doc 3 §11 layer 2 — an engine-level refusal from a raw-SQL path, translated into the same
+		   vocabulary the ORM path uses. Without this it reaches the browser as a bare 500. */
+		const engineRefusal = describeRlsFailure(error);
+		if (engineRefusal) {
+			return {
+				status: engineRefusal.status,
+				body: { error: engineRefusal.message, code: engineRefusal.code },
+			};
+		}
+		/* Found live 2026-10-07: a refused save reached the user as SQL. A refusal the user can act on is named by the
+		   field's label; anything else keeps its message, never the statement — that goes to the hub log only. */
+		const refusal = describeDatabaseRefusal(error, { labelOf: (table, column) => labelFor(table, column, dbIndex) });
+		if (refusal) {
+			logger.info(`[orm] ${refusal.code}: ${error?.message ?? error}`);
+			return { status: refusal.status, body: { error: refusal.message, code: refusal.code } };
+		}
+		logger.error(`[orm] ${error?.message ?? error}`);
+		return { status: 500, body: { error: withoutStatement(error?.message ?? String(error)) } };
 	}
 };

package/engine/orm/entityConfig.js

@@ -340,39 +340,9 @@ export const buildTenancyMap = (parsedDomainConfigs = []) => {
  * the answer — and is also what creates the `deleted_at` column, so a declaration and its column
  * arrive together.
  */
-/*
- * Doc 8 M3 — an EXTERNAL entity is another system's table (FINA's GLACCNT, in FINA's own database), declared for the
- * screens only. Every map below is keyed by TABLE NAME for the tenant database, so its declarations — a soft delete, a
- * boolean column, a relationship — would apply to any tenant table that happened to share the name. They are dropped
- * before any map is built, with every relationship that names one of them.
- */
-const isExternal = (entity) => entity?.external === true || String(entity?.external ?? "").trim().toLowerCase() === "true";
-const withoutExternalEntities = (configs) =>
-	(Array.isArray(configs) ? configs : []).map((config) => {
-		const entities = config?.model?.entities;
-		if (!entities || typeof entities !== "object") return config;
-		const external = new Set();
-		const kept = {};
-		for (const [name, entity] of Object.entries(entities)) {
-			if (!isExternal(entity)) {
-				kept[name] = entity;
-				continue;
-			}
-			external.add(String(name).toLowerCase());
-			if (entity?.table) external.add(String(entity.table).toLowerCase());
-		}
-		if (external.size === 0) return config;
-		const relationships = Object.fromEntries(
-			Object.entries(config.model.relationships ?? {}).filter(
-				([, r]) => !external.has(String(r?.from ?? "").toLowerCase()) && !external.has(String(r?.to ?? "").toLowerCase()),
-			),
-		);
-		return { ...config, model: { ...config.model, entities: kept, relationships } };
-	});
-
 export const primeEntityConfig = async ({ dbIndex, loadDomainConfigs }) => {
 	try {
-		const configs = withoutExternalEntities(await loadDomainConfigs());
+		const configs = await loadDomainConfigs();
 		const map = buildEntityMap(configs);
 		const relationships = buildRelationshipMap(configs);
 		const foreignKeys = buildForeignKeyMap(configs);
@@ -683,7 +653,7 @@ export const tenantColumnFor = (table, dbIndex) => {
    table's — see stampTenant. */
 const isTenantTable = (table, dbIndex) =>
 	String(table ?? "").trim().toLowerCase() ===
-	(byDbIndex.get(Number(dbIndex))?.tenancy?.tenantTable ?? "\u0000");
+	(byDbIndex.get(Number(dbIndex))?.tenancy?.tenantTable ?? "");
 
 /* The entity whose rows ARE tenants, for the RLS policy emission in a later slice. */
 export const tenantTableFor = (dbIndex) => byDbIndex.get(Number(dbIndex))?.tenancy?.tenantTable ?? null;

package/engine/orm/finaEndpoint.js

@@ -24,7 +24,6 @@ import { runAsPrincipal, ACTIVE_TENANT_NOT_HELD } from "./tenantContext.js";
 import { resolveRequestScope, SESSION_NOT_USABLE } from "./requestScope.js";
 import { authorizeRequest } from "../../security/internalPrincipal.js";
 import { describePrincipalObservation, isPreAuthRequest } from "./dataSnapShape.js";
-import { refuseFinaCloudWrite } from "../fina/guard.js";
 import { logger } from "../../logger.js";
 
 const DATASNAP_PATH = /\/fina\/rest\/(\w+)\/(?:%22|")(\w+)(?:%22|")/i;
@@ -53,10 +52,6 @@ export const handleFinaRequest = async (
 		chooseActiveTenant = null,
 		/* Starts the workflow an entity declares when a v2 save creates one of its records (apiRoute). */
 		startWorkflow = null,
-		/* Doc 8 — the FINA Cloud database (hub --finaCloudDbindex); absent = FINA Cloud off. */
-		finaCloudDbIndex = null,
-		/* Doc 8 M8 — the FINA read policy (engine/fina/readPolicy.js): reading FINA takes a mapped FINA user. */
-		finaReadPolicy = null,
 	},
 ) => {
 	/*
@@ -162,14 +157,6 @@ export const handleFinaRequest = async (
 		};
 	}
 
-	/* Doc 8 D2 — a browser may not write to the FINA Cloud database directly; engine/fina does it, checking the
-	   user's FINA rights and the date lock. Same guard as the socket entrance (bin/hubEvent.js). */
-	const refused = refuseFinaCloudWrite({ path, body, finaCloudDbIndex }) ?? (finaReadPolicy ? await finaReadPolicy({ path, body, headers }) : null);
-	if (refused) {
-		logger.warn(`[apiRequest] refused ${path}: ${refused.body.error}`);
-		return refused;
-	}
-
 	try {
 		const forwarded = await forwardToApi({ path, body });
 		/* Doc 6 on Firebird — a login FINA answered gets its principal here (apiRoute.js). */
@@ -245,12 +232,6 @@ export const createFinaRouter = (deps) => {
 			res.set("Access-Control-Expose-Headers", "biza-cli-address, biza-hub-address");
 		}
 
-		/* ⚠️ An image read answers BYTES (apiRoute.js `img`), and this is the route `<img src>` takes.
-		   `res.json` would send `{"type":"Buffer","data":[…]}` — a 200 the browser cannot draw. */
-		if (Buffer.isBuffer(result.body)) {
-			res.status(result.status).type(result.contentType ?? "application/octet-stream").send(result.body);
-			return;
-		}
 		res.status(result.status).json(result.body);
 	});
 	return router;

package/engine/orm/imgQuery.js

@@ -5,7 +5,6 @@
  * together; the update binds `:logo` / `:format` / `:key` parameters, which the execution layer
  * supplies. Values arrive pre-quoted from the caller, matching the rest of this ORM.
  */
-import { assertIdentifier, assertQualifiedIdentifier, assertKeyLiteral } from "./sqlGuard.js";
 
 const CONTENT_TYPES = {
 	jpg: "image/jpeg",
@@ -67,97 +66,6 @@ export const buildUpdateImg = (request = {}) => {
 	};
 };
 
-/*
- * ⚠️⚠️ THE SAME ENDPOINT ON POSTGRESQL — and why the builders above cannot simply be run.
- *
- * `buildUpdateImg` emits Delphi's `:logo` / `:key` placeholders, which node-pg does not understand,
- * and `buildGetImgSql` interpolates the key into the statement. Neither was ever wired to a route:
- * the client builds both paths UNQUOTED (`getUrlApi(config, 'img', false)`), so apiRoute never
- * recognised them and they fell through to FINA. On a PostgreSQL tenant that FINA holds a different
- * database, and it answered `success: "OK"` for an UPDATE that matched nothing — Supertail's item
- * image kept a NULL CONTENT and nobody was told (studioa, 2026-10-09).
- *
- * These build `{text, values}` for node-pg instead. Names are checked as plain identifiers; the key
- * is BOUND, never interpolated, so a key value cannot become SQL. The FINA builders above stay as
- * they are — tests/orm-parity.test.js pins them to orm.pas.
- */
-const TEXT_COLUMN_TYPES = new Set(["text", "character varying", "character"]);
-
-/* The write request, checked in orm.pas's order and with its messages, plus the identifier guard. */
-export const readUpdateImgRequest = (request = {}) => {
-	const tableName = assertQualifiedIdentifier(requireField(request, "tableName"), "img table");
-	const imgCol = assertIdentifier(requireField(request, "imgCol"), "img column");
-	const keyCol = assertIdentifier(requireField(request, "keyCol"), "img key column");
-	const img = requireField(request, "img");
-	const key = requireField(request, "keyValue");
-	requireField(request, "dbIndex");
-	const useFormat = request.formatValue !== undefined && request.formatValue !== null;
-	return {
-		tableName,
-		imgCol,
-		keyCol,
-		img: String(img),
-		key: String(key),
-		formatCol: useFormat ? assertIdentifier(requireField(request, "formatCol"), "img format column") : "",
-		format: useFormat ? String(request.formatValue).toUpperCase() : "",
-	};
-};
-
-/* Whether the target column is text rather than bytea. Firebird has one BLOB type for both, so the
-   request cannot say; binding a Buffer to a text column would store the literal `\x…` escape. */
-export const buildImgColumnTypeSql = ({ tableName, imgCol }) => ({
-	text:
-		"SELECT data_type FROM information_schema.columns " +
-		"WHERE table_schema = current_schema() AND table_name = lower($1) AND column_name = lower($2)",
-	values: [String(tableName), String(imgCol)],
-});
-
-export const isTextColumnType = (dataType) => TEXT_COLUMN_TYPES.has(String(dataType ?? "").toLowerCase());
-
-/* ⚠️ RETURNING the key: FINA cannot tell an UPDATE that hit nothing from one that worked, and that
-   blindness is the bug this exists to fix. The caller refuses an empty result. */
-export const buildPgUpdateImg = ({ tableName, imgCol, keyCol, img, key, formatCol, format }, { textColumn = false } = {}) => {
-	const bytes = Buffer.from(img, "base64");
-	const values = [textColumn ? bytes.toString("utf8") : bytes, key];
-	let assignments = `${imgCol} = $1`;
-	if (formatCol) {
-		assignments += `, ${formatCol} = $3`;
-		values.push(format);
-	}
-	return { text: `UPDATE ${tableName} SET ${assignments} WHERE ${keyCol} = $2 RETURNING ${keyCol}`, values };
-};
-
-/* GET /fina/rest/<Class>/img/<dbIndex>/<table>/<keyCol>/<imgCol>/<value>[/<formatCol>] — FINA's
-   `TOrmMethod.img(dbIndex, table, key, img, value, imgFormat)`, one segment per argument. */
-const IMG_GET_PATH = /\/fina\/rest\/\w+\/img\/(\d+)\/([^/?#]+)\/([^/?#]+)\/([^/?#]+)\/([^/?#]+)(?:\/([^/?#]+))?\/?(?:[?#]|$)/i;
-
-/* Never throws: a path it cannot read is not a read it serves. */
-export const parseImgGetPath = (path) => {
-	const match = IMG_GET_PATH.exec(String(path ?? ""));
-	if (!match) return null;
-	try {
-		const [table, keyCol, imgCol, value, formatCol] = match.slice(2).map((part) =>
-			part === undefined ? "" : decodeURIComponent(part),
-		);
-		return { dbIndex: Number(match[1]), table, keyCol, imgCol, value, formatCol };
-	} catch {
-		return null;
-	}
-};
-
-/* The key arrives pre-quoted for FINA's interpolation (`'{GUID}'`, img-formly.component.ts). It must
-   be ONE literal; its quotes are then taken off and the value bound. */
-export const buildPgGetImg = ({ table, keyCol, imgCol, formatCol = "", value }) => {
-	assertQualifiedIdentifier(table, "img table");
-	assertIdentifier(keyCol, "img key column");
-	assertIdentifier(imgCol, "img column");
-	if (formatCol) assertIdentifier(formatCol, "img format column");
-	const literal = String(assertKeyLiteral(value, "img key")).trim();
-	const key = literal.startsWith("'") ? literal.slice(1, -1).replace(/''/g, "'") : literal;
-	const columns = formatCol ? `${imgCol}, ${formatCol}` : imgCol;
-	return { text: `SELECT ${columns} FROM ${table} WHERE ${keyCol} = $1`, values: [key] };
-};
-
 /*
  * Result post-processing: the driver returns rows keyed by bare column name, but callers address
  * them by the FULL requested key (`tn.a`), which is what disambiguates two joined columns that

package/engine/orm/listQuery.js

@@ -192,12 +192,7 @@ const buildCondition = (filter, registry, dbIndex) => {
 	 */
 	const lowered = operator.toLowerCase().replace(/\s+/g, " ").trim();
 	if ((lowered === CONTAINING || lowered === NOT_CONTAINING) && isPostgresIndex(dbIndex)) {
-		/*
-		 * ⚠️ Read as text: Firebird's CONTAINING converts a number or a date, PostgreSQL's ILIKE takes text
-		 * only — `bigint ILIKE` is "operator does not exist", and one number column in a search made the
-		 * whole search an error. A no-op for a text column.
-		 */
-		const rendered2 = `${junction ? ` ${junction}` : ""} CAST(${column} AS text) ${lowered === NOT_CONTAINING ? "NOT ILIKE" : "ILIKE"}`;
+		const rendered2 = `${junction ? ` ${junction}` : ""} ${column} ${lowered === NOT_CONTAINING ? "NOT ILIKE" : "ILIKE"}`;
 		return `${rendered2} ${toContainingPattern(assertSearchLiteral(filter.value1, "containing value"))}`;
 	}
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "biz-a-cli",
-	"version": "2.3.80-15419",
+	"version": "2.3.80",
 	"description": "",
 	"main": "bin/index.js",
 	"type": "module",

package/worker/cliScriptWorker.js

@@ -4,7 +4,6 @@ import * as db from "../db/db.js";
 import { ensureEntityConfig } from "../engine/domain/entityConfigPrimer.js";
 import { resolveUserGroups, resolveIsAdministrator } from "../engine/orm/userGroups.js";
 import { execPostgres } from "../engine/domain/dialect.js";
-import { finaScriptLib } from "../engine/fina/approvalService.js";
 import { logger } from "../logger.js";
 
 // export const run = async (apiConfig, scriptIdentifier, scriptData) => {
@@ -181,10 +180,6 @@ export const run = async (apiConfig, scriptIdentifier, scriptData, principal = n
 			/* Doc 4 §9.4 — terminate sessions; see db.js session(). */
 			session: (customCfg) => db.session(mergeConfig(customCfg)),
 		};
-
-		/* Doc 8 M7 — FINA Cloud's JV approval effects (engine/fina/approvalService.js). The instance a script names decides
-		   what happens and the JV is posted as its submitter, never as anyone the script says. */
-		lib.fina = finaScriptLib(baseConfig, { emitUsers: lib.emitUsers });
 	};
 
 	try {