@plusscommunities/pluss-core-aws 2.0.26-auth.0 → 2.0.26-beta.0

package/db/notifications/publishNotifications.js

@@ -5,50 +5,50 @@ const sendNotifications = require("../../notification/sendNotifications");
 const prepNotification = require("../../notification/prepNotification");
 
 const saveNotification = (receiver, notification) => {
-  const toSave = { ...notification };
+	const toSave = { ...notification };
 
-  toSave.UserId = receiver;
-  toSave.RowId = getMultiRowId([toSave.Site, toSave.Type, toSave.Id, receiver]);
-  toSave.Seen = false;
-  toSave.Clicked = false;
+	toSave.UserId = receiver;
+	toSave.RowId = getMultiRowId([toSave.Site, toSave.Type, toSave.Id, receiver]);
+	toSave.Seen = false;
+	toSave.Clicked = false;
 
-  updateRef(`notifications`, toSave)
-    .then(() => {
-      //resolve();
-    })
-    .catch((error) => {
-      //reject(error);
-    });
+	updateRef(`notifications`, toSave)
+		.then(() => {
+			//resolve();
+		})
+		.catch((error) => {
+			//reject(error);
+		});
 };
 
 module.exports = async (
-  receivers,
-  type,
-  site,
-  id,
-  data,
-  sendPush,
-  config = { type: "app", id: null, ignoreMute: false, raiseError: false }
+	receivers,
+	type,
+	site,
+	id,
+	data,
+	sendPush,
+	config = { type: "app", id: null, ignoreMute: false, raiseError: false },
 ) => {
-  const notification = {};
-  notification.Timestamp = moment.utc().valueOf();
-  notification.Type = type;
-  notification.Site = site;
-  notification.Id = id;
-  notification.Data = data;
+	const notification = {};
+	notification.Timestamp = moment.utc().valueOf();
+	notification.Type = type;
+	notification.Site = site;
+	notification.Id = id;
+	notification.Data = data;
 
-  receivers.forEach((receiver) => {
-    saveNotification(receiver, notification);
-  });
-  if (sendPush) {
-    const notiData = prepNotification(notification);
-    await sendNotifications(
-      receivers,
-      notiData.Text,
-      type,
-      id,
-      notiData,
-      config
-    );
-  }
+	receivers.forEach((receiver) => {
+		saveNotification(receiver, notification);
+	});
+	if (sendPush) {
+		const notiData = prepNotification(notification);
+		await sendNotifications(
+			receivers,
+			notiData.Text,
+			type,
+			id,
+			notiData,
+			config,
+		);
+	}
 };

package/db/postgres/getKnex.js

@@ -0,0 +1,214 @@
+const AWS = require("aws-sdk");
+const knex = require("knex");
+const safeError = require("./safeError");
+const { log, generateLogId } = require("../../helper");
+
+const secrets = new AWS.SecretsManager();
+
+let db;
+let pending;
+let generation = 0;
+
+const SUPERSEDED_INITIALISATION = "POSTGRES_CLIENT_SUPERSEDED";
+const STALE_CLIENT_DESTROY_FAILED = "POSTGRES_STALE_CLIENT_DESTROY_FAILED";
+
+function poolMax() {
+	return Number(process.env.POSTGRES_POOL_MAX || 1);
+}
+
+function secretArn() {
+	return process.env.POSTGRES_SECRET_ARN;
+}
+
+let sslWarningEmitted = false;
+
+function ssl() {
+	if (process.env.POSTGRES_SSL === "disable") {
+		return false;
+	}
+
+	const rejectUnauthorized =
+		process.env.POSTGRES_SSL_REJECT_UNAUTHORIZED !== "false";
+
+	// Certificate verification is on by default. If a local/dev environment needs
+	// to opt out, log that once so the downgrade is visible in runtime logs.
+	if (!rejectUnauthorized && !sslWarningEmitted) {
+		sslWarningEmitted = true;
+		log("getKnex", "SslVerificationDisabled", {
+			reason:
+				"POSTGRES_SSL_REJECT_UNAUTHORIZED=false disables server certificate verification",
+		});
+	}
+
+	return { rejectUnauthorized };
+}
+
+const SECRET_FIELDS = {
+	host: "host",
+	username: "username",
+	password: "password",
+	dbname: "dbname",
+};
+
+async function secretConnection(arn) {
+	let result;
+	try {
+		result = await secrets.getSecretValue({ SecretId: arn }).promise();
+	} catch (error) {
+		// AWS SDK fetch errors describe the API call, not the secret body. Keep the
+		// message so the ARN points operators at the failed secret.
+		throw new Error(`Failed to load secret ${arn}: ${error.message}`);
+	}
+
+	let secret;
+	try {
+		secret = JSON.parse(result.SecretString);
+	} catch (error) {
+		// V8 SyntaxError messages include a slice of the parsed input. If SecretString
+		// is a bare connection string, error.message would leak credentials.
+		throw new Error(`Failed to parse secret ${arn} as JSON`);
+	}
+
+	if (!secret || typeof secret !== "object") {
+		// JSON.parse("null") or a bare primitive would otherwise become a TypeError
+		// without ARN context. Treat it as a bad secret body.
+		throw new Error(`Failed to parse secret ${arn} as JSON`);
+	}
+
+	const missing = Object.keys(SECRET_FIELDS).filter((field) => !secret[field]);
+	if (missing.length) {
+		// A secret missing host makes node-postgres silently dial localhost; a
+		// missing username/dbname falls back to the OS user / default db. Fail
+		// loudly with the field names (never their values).
+		throw new Error(`Secret ${arn} is missing fields: ${missing.join(", ")}`);
+	}
+
+	return {
+		host: secret.host,
+		port: secret.port ? Number(secret.port) : 5432,
+		database: secret.dbname,
+		user: secret.username,
+		password: secret.password,
+	};
+}
+
+function configSourceVar() {
+	if (process.env.POSTGRES_SECRET_ARN) return "POSTGRES_SECRET_ARN";
+	return undefined;
+}
+
+async function connection() {
+	const arn = secretArn();
+	if (!arn) {
+		throw new Error("PostgreSQL connection requires POSTGRES_SECRET_ARN");
+	}
+	return secretConnection(arn);
+}
+
+async function createKnex(overrides = {}) {
+	const database = await connection();
+	const max = overrides.poolMax || poolMax();
+
+	// This log is not gated by enableLog. Log the source and host only, never the
+	// secret ARN or credentials.
+	log("getKnex", "CreatingClient", {
+		source: configSourceVar(),
+		host: database.host || "url",
+		max,
+	});
+
+	const instance = knex({
+		client: "pg",
+		// Knex otherwise mutates error.message to inline bound values in the
+		// compiled SQL. Keep thrown errors parameterized; log paths use safeError().
+		compileSqlOnError: false,
+		connection: {
+			...database,
+			ssl: ssl(),
+			connectionTimeoutMillis: 10000,
+		},
+		pool: {
+			min: 0,
+			max,
+			idleTimeoutMillis: 60000,
+			acquireTimeoutMillis: 10000,
+		},
+	});
+
+	instance.on("query-error", (error) => {
+		// Use a fresh id per event. Reusing the pool-creation id would put every
+		// query error from this instance under one trace id.
+		log("getKnex", "QueryError", safeError(error), generateLogId());
+	});
+
+	return instance;
+}
+
+async function getKnex() {
+	if (db) return db;
+	if (!pending) {
+		const pendingGeneration = generation;
+		pending = createKnex()
+			.then(async (instance) => {
+				if (generation !== pendingGeneration) {
+					try {
+						await instance.destroy();
+					} catch (destroyError) {
+						log("getKnex", "DestroyStaleError", safeError(destroyError));
+						const error = new Error(
+							`Failed to destroy superseded PostgreSQL client: ${destroyError.message}`,
+						);
+						error.code = STALE_CLIENT_DESTROY_FAILED;
+						error.cause = destroyError;
+						throw error;
+					}
+					const error = new Error(
+						"PostgreSQL client initialisation was superseded by destroy()",
+					);
+					error.code = SUPERSEDED_INITIALISATION;
+					throw error;
+				}
+				db = instance;
+				return instance;
+			})
+			.catch((error) => {
+				if (generation === pendingGeneration) pending = undefined;
+				throw error;
+			});
+	}
+	return pending;
+}
+
+getKnex.destroy = async () => {
+	const instance = db;
+	const initializer = pending;
+	generation += 1;
+	db = undefined;
+	pending = undefined;
+	if (instance) {
+		await instance.destroy();
+		return;
+	}
+
+	if (initializer) {
+		try {
+			await initializer;
+		} catch (error) {
+			// A pending initializer can reject because destroy() intentionally
+			// superseded it. Surface stale-pool cleanup failures, but keep benign
+			// cancellation and unrelated initializer failures out of teardown.
+			if (error?.code === STALE_CLIENT_DESTROY_FAILED) throw error;
+		}
+	}
+};
+
+// Create a non-singleton client. The migration runner sets poolMax: 2 because
+// the advisory-lock connection stays checked out while migration queries use a
+// second slot. The caller owns destroy().
+getKnex.create = (overrides) => createKnex(overrides);
+
+// Shared so the bootstrap path (provisionDatabaseUsers) honours the same
+// POSTGRES_SSL / POSTGRES_SSL_REJECT_UNAUTHORIZED overrides as the pool.
+getKnex.sslConfig = ssl;
+
+module.exports = getKnex;

package/db/postgres/safeError.js

@@ -0,0 +1,40 @@
+const PG_FIELDS = [
+	"code",
+	"severity",
+	"schema",
+	"table",
+	"column",
+	"constraint",
+	"routine",
+];
+
+// knex prefixes driver errors with compiled SQL and inlined bindings:
+// "<compiled sql> - <original message>". Strip through the last " - " so
+// bindings stay out of logs while the useful driver message survives.
+function stripCompiledSql(message) {
+	const separator = message.lastIndexOf(" - ");
+	return separator === -1 ? message : message.slice(separator + 3);
+}
+
+function safeError(error) {
+	if (!error || typeof error !== "object") return { message: String(error) };
+
+	const output = {
+		name: error.name,
+	};
+
+	for (const field of PG_FIELDS) {
+		if (error[field]) output[field] = error[field];
+	}
+
+	// Keep a message. Structured PG fields cover constraint-class errors, but
+	// codes like 42P01 would otherwise lose the missing relation name. detail,
+	// hint, and where can carry raw values, so leave them out.
+	output.message = stripCompiledSql(String(error.message || error)).slice(
+		0,
+		512,
+	);
+	return output;
+}
+
+module.exports = safeError;

package/db/property/Property.js

@@ -0,0 +1,128 @@
+/**
+ * A property row from pc_property.properties, validated on construction.
+ *
+ * Build with Property.fromRow(row); the constructor rejects rows that break a
+ * domain invariant so a repository never hands a handler an unvalidated record.
+ */
+class Property {
+	#row;
+
+	constructor(row) {
+		if (!row) {
+			throw new Error("Property requires a row");
+		}
+		Property.assertValid(row);
+		this.#row = { ...row };
+	}
+
+	static fromRow(row) {
+		return new Property(row);
+	}
+
+	static assertValid(row) {
+		if (!row.id) throw new Error("Property requires an id");
+		if (!row.site_id) throw new Error("Property requires a site_id");
+		if (!row.name) throw new Error("Property requires a name");
+		if (row.status !== "active" && row.status !== "archived") {
+			throw new Error(`Property has an invalid status: ${row.status}`);
+		}
+	}
+
+	get id() {
+		return this.#row.id;
+	}
+
+	get site() {
+		return this.#row.site_id;
+	}
+
+	get name() {
+		return this.#row.name;
+	}
+
+	get propertyType() {
+		return this.#row.property_type ?? null;
+	}
+
+	get location() {
+		return this.#row.location ?? null;
+	}
+
+	get status() {
+		return this.#row.status;
+	}
+
+	get externalId() {
+		return this.#row.external_id ?? null;
+	}
+
+	get metadata() {
+		return this.#row.metadata ?? {};
+	}
+
+	get createdBy() {
+		return this.#row.created_by ?? null;
+	}
+
+	get residentCount() {
+		return this.#row.resident_count !== undefined
+			? Number(this.#row.resident_count)
+			: undefined;
+	}
+
+	get timeCreated() {
+		return this.#row.time_created ?? null;
+	}
+
+	get timeUpdated() {
+		return this.#row.time_updated ?? null;
+	}
+
+	get timeDeleted() {
+		return this.#row.time_deleted ?? null;
+	}
+
+	get isActive() {
+		return this.#row.status === "active";
+	}
+
+	get isArchived() {
+		return this.#row.status === "archived";
+	}
+
+	get isDeleted() {
+		return this.#row.time_deleted != null;
+	}
+
+	get canLinkResidents() {
+		return this.isActive && !this.isDeleted;
+	}
+
+	toRow() {
+		return { ...this.#row };
+	}
+
+	toApi() {
+		return {
+			id: this.#row.id,
+			site: this.#row.site_id,
+			name: this.#row.name,
+			propertyType: this.#row.property_type ?? null,
+			location: this.#row.location ?? null,
+			status: this.#row.status,
+			externalId: this.#row.external_id ?? null,
+			metadata: this.#row.metadata ?? {},
+			createdBy: this.#row.created_by ?? null,
+			// undefined (not null) so the key drops out of the JSON when there is no count.
+			residentCount:
+				this.#row.resident_count !== undefined
+					? Number(this.#row.resident_count)
+					: undefined,
+			timeCreated: this.#row.time_created ?? null,
+			timeUpdated: this.#row.time_updated ?? null,
+			timeDeleted: this.#row.time_deleted ?? null,
+		};
+	}
+}
+
+module.exports = { Property };

package/db/property/PropertyRepository.js

@@ -0,0 +1,86 @@
+const getKnex = require("../postgres/getKnex");
+const { log } = require("../../helper");
+const { Property } = require("./Property");
+
+// PostgreSQL schema owned by the property service.
+const SCHEMA = "pc_property";
+const PROPERTIES = "properties";
+const PROPERTY_USERS = "property_users";
+
+const UUID_PATTERN =
+	/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Read-only property lookups against the pc_property schema.
+ *
+ * Writes stay with the property service; extensions only resolve. Methods
+ * return Property entities or null — never raw rows.
+ */
+class PropertyRepository {
+	/**
+	 * Resolve the property a user is linked to at a site.
+	 *
+	 * @param {object} input
+	 * @param {string} input.site
+	 * @param {string} input.userId
+	 * @param {string} [input.logId] - optional trace id
+	 * @returns {Promise<Property|null>} the linked property, or null when the user has no live link
+	 * @throws {Error} on query failure, or when a live link references a missing property
+	 */
+	async forUser({ site, userId, logId }) {
+		if (!site || !userId) {
+			throw new Error("PropertyRepository.forUser requires site and userId");
+		}
+		log("PropertyRepository_forUser", "Input", { site, userId }, logId);
+
+		const knex = await getKnex();
+		// A user has at most one live property link.
+		const link = await knex
+			.withSchema(SCHEMA)
+			.table(PROPERTY_USERS)
+			.where({ user_id: userId, site_id: site, time_deleted: null })
+			.first();
+		if (!link) return null;
+
+		const row = await knex
+			.withSchema(SCHEMA)
+			.table(PROPERTIES)
+			.where({ id: link.property_id, site_id: site, time_deleted: null })
+			.first();
+		if (!row) {
+			throw new Error(
+				`Property link integrity violation: link ${link.id} references missing property ${link.property_id} for user ${userId}`,
+			);
+		}
+		return Property.fromRow(row);
+	}
+
+	/**
+	 * Resolve a property by id, scoped to a site.
+	 *
+	 * @param {object} input
+	 * @param {string} input.site
+	 * @param {string} input.propertyId
+	 * @param {string} [input.logId] - optional trace id
+	 * @returns {Promise<Property|null>} the property, or null when none matches at the site
+	 * @throws {Error} on query failure
+	 */
+	async byId({ site, propertyId, logId }) {
+		if (!site || !propertyId) {
+			throw new Error("PropertyRepository.byId requires site and propertyId");
+		}
+		// A malformed id can't match anything; don't let it become a Postgres cast error.
+		if (!UUID_PATTERN.test(propertyId)) return null;
+		log("PropertyRepository_byId", "Input", { site, propertyId }, logId);
+
+		const knex = await getKnex();
+		const row = await knex
+			.withSchema(SCHEMA)
+			.table(PROPERTIES)
+			.where({ id: propertyId, site_id: site, time_deleted: null })
+			.first();
+		return row ? Property.fromRow(row) : null;
+	}
+}
+
+module.exports = { PropertyRepository };

package/db/scheduledActions/deleteActionQueue.js

@@ -1,5 +1,5 @@
 const deleteRef = require("../common/deleteRef");
 
 module.exports = (id) => {
-  return deleteRef("actionqueue", "RowId", id);
+	return deleteRef("actionqueue", "RowId", id);
 };

package/db/scheduledActions/getActionQueueByEntityId.js

@@ -1,15 +1,15 @@
 const indexQuery = require("../common/indexQuery");
 
 module.exports = async (entityKey, entityId) => {
-  const query = {
-    IndexName: "EntityKeyEntityIdIndex",
-    KeyConditionExpression: "EntityKey = :entityKey and EntityId = :entityId",
-    ExpressionAttributeValues: {
-      ":entityKey": entityKey,
-      ":entityId": entityId,
-    },
-  };
+	const query = {
+		IndexName: "EntityKeyEntityIdIndex",
+		KeyConditionExpression: "EntityKey = :entityKey and EntityId = :entityId",
+		ExpressionAttributeValues: {
+			":entityKey": entityKey,
+			":entityId": entityId,
+		},
+	};
 
-  const { Items } = await indexQuery("actionqueue", query);
-  return Items;
+	const { Items } = await indexQuery("actionqueue", query);
+	return Items;
 };

package/db/scheduledActions/getActionQueueByEntityKey.js

@@ -1,14 +1,14 @@
 const indexQueryRecursive = require("../common/indexQueryRecursive");
 
 module.exports = async (site, entityKey) => {
-  const query = {
-    IndexName: "SiteEntityKeyIndex",
-    KeyConditionExpression: "Site = :site and EntityKey = :entityKey",
-    ExpressionAttributeValues: {
-      ":site": site,
-      ":entityKey": entityKey,
-    },
-  };
+	const query = {
+		IndexName: "SiteEntityKeyIndex",
+		KeyConditionExpression: "Site = :site and EntityKey = :entityKey",
+		ExpressionAttributeValues: {
+			":site": site,
+			":entityKey": entityKey,
+		},
+	};
 
-  return await indexQueryRecursive("actionqueue", query);
+	return await indexQueryRecursive("actionqueue", query);
 };

package/db/scheduledActions/getActionQueueById.js

@@ -1,13 +1,13 @@
 const getRef = require("../common/getRef");
 
 module.exports = (rowId) => {
-  return new Promise((resolve, reject) => {
-    getRef("actionqueue", "RowId", rowId)
-      .then((ev) => {
-        resolve(ev);
-      })
-      .catch((error) => {
-        reject(error);
-      });
-  });
+	return new Promise((resolve, reject) => {
+		getRef("actionqueue", "RowId", rowId)
+			.then((ev) => {
+				resolve(ev);
+			})
+			.catch((error) => {
+				reject(error);
+			});
+	});
 };

package/db/scheduledActions/getActionQueueByTriggerAt.js

@@ -1,20 +1,20 @@
 const indexQueryRecursive = require("../common/indexQueryRecursive");
 
 module.exports = async (
-  site,
-  minTime = 0,
-  maxTime = Number.MAX_SAFE_INTEGER
+	site,
+	minTime = 0,
+	maxTime = Number.MAX_SAFE_INTEGER,
 ) => {
-  const query = {
-    IndexName: "SiteTriggerAtIndex",
-    KeyConditionExpression:
-      "Site = :site AND TriggerAt BETWEEN :minTime and :maxTime",
-    ExpressionAttributeValues: {
-      ":site": site,
-      ":minTime": minTime,
-      ":maxTime": maxTime,
-    },
-  };
+	const query = {
+		IndexName: "SiteTriggerAtIndex",
+		KeyConditionExpression:
+			"Site = :site AND TriggerAt BETWEEN :minTime and :maxTime",
+		ExpressionAttributeValues: {
+			":site": site,
+			":minTime": minTime,
+			":maxTime": maxTime,
+		},
+	};
 
-  return await indexQueryRecursive("actionqueue", query);
+	return await indexQueryRecursive("actionqueue", query);
 };