Skip to content

Node.js based forum software built for the modern web

10.0 KB
Raw Blame
'use strict';

module.exports = function (module) {
	const helpers = require('./helpers');

	const cache = require('../cache').create('postgres');

	module.objectCache = cache;

	module.setObject = async function (key, data) {
		if (!key || !data) {
			return;
		}

		if (data.hasOwnProperty('')) {
			delete data[''];
		}
		if (!Object.keys(data).length) {
			return;
		}
		await module.transaction(async (client) => {
			const dataString = JSON.stringify(data);

			if (Array.isArray(key)) {
				await helpers.ensureLegacyObjectsType(client, key, 'hash');
				await client.query({
					name: 'setObjectKeys',
					text: `
	INSERT INTO "legacy_hash" ("_key", "data")
	SELECT k, $2::TEXT::JSONB
	FROM UNNEST($1::TEXT[]) vs(k)
	ON CONFLICT ("_key")
	DO UPDATE SET "data" = "legacy_hash"."data" || $2::TEXT::JSONB`,
					values: [key, dataString],
				});
			} else {
				await helpers.ensureLegacyObjectType(client, key, 'hash');
				await client.query({
					name: 'setObject',
					text: `
	INSERT INTO "legacy_hash" ("_key", "data")
	VALUES ($1::TEXT, $2::TEXT::JSONB)
	ON CONFLICT ("_key")
	DO UPDATE SET "data" = "legacy_hash"."data" || $2::TEXT::JSONB`,
					values: [key, dataString],
				});
			}
		});
		cache.del(key);
	};

	module.setObjectBulk = async function (...args) {
		let data = args[0];
		if (!Array.isArray(data) || !data.length) {
			return;
		}
		if (Array.isArray(args[1])) {
			console.warn('[deprecated] db.setObjectBulk(keys, data) usage is deprecated, please use db.setObjectBulk(data)');
			// conver old format to new format for backwards compatibility
			data = args[0].map((key, i) => [key, args[1][i]]);
		}
		data = data.filter((item) => {
			if (item[1].hasOwnProperty('')) {
				delete item[1][''];
			}
			return !!Object.keys(item[1]).length;
		});
		const keys = data.map(item => item[0]);
		if (!keys.length) {
			return;
		}
		await module.transaction(async (client) => {
			await helpers.ensureLegacyObjectsType(client, keys, 'hash');
			const dataStrings = data.map(item => JSON.stringify(item[1]));
			await client.query({
				name: 'setObjectBulk',
				text: `
			INSERT INTO "legacy_hash" ("_key", "data")
			SELECT k, d
			FROM UNNEST($1::TEXT[], $2::TEXT::JSONB[]) vs(k, d)
			ON CONFLICT ("_key")
			DO UPDATE SET "data" = "legacy_hash"."data" || EXCLUDED.data`,
				values: [keys, dataStrings],
			});
		});
		cache.del(keys);
	};

	module.setObjectField = async function (key, field, value) {
		if (!field) {
			return;
		}
		if (Array.isArray(key)) {
			return await module.setObject(key, { [field]: value });
		}
		await module.transaction(async (client) => {
			const valueString = JSON.stringify(value);
			await helpers.ensureLegacyObjectType(client, key, 'hash');
			await client.query({
				name: 'setObjectField',
				text: `
			INSERT INTO "legacy_hash" ("_key", "data")
			VALUES ($1::TEXT, jsonb_build_object($2::TEXT, $3::TEXT::JSONB))
			ON CONFLICT ("_key")
			DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], $3::TEXT::JSONB)`,
				values: [key, field, valueString],
			});
		});

		cache.del(key);
	};

	module.getObject = async function (key, fields = []) {
		if (!key) {
			return null;
		}

		const data = await module.getObjects([key], fields);
		return data && data.length ? data[0] : null;
	};

	module.getObjects = async function (keys, fields = []) {
		return await module.getObjectsFields(keys, fields);
	};

	module.getObjectField = async function (key, field) {
		if (!key || !field) {
			return null;
		}
		const cachedData = cache.get(key);
		if (cachedData !== undefined) {
			return cachedData?.hasOwnProperty(field) ? cachedData[field] : null;
		}

		const res = await module.pool.query({
			name: 'getObjectField',
			text: `
SELECT h."data"->>$2::TEXT f
  FROM "legacy_object_live" o
 INNER JOIN "legacy_hash" h
         ON o."_key" = h."_key"
        AND o."type" = h."type"
 WHERE o."_key" = $1::TEXT
 LIMIT 1`,
			values: [key, field],
		});

		return res.rows.length ? res.rows[0].f : null;
	};

	module.getObjectFields = async function (key, fields) {
		if (!key) {
			return null;
		}
		const data = await module.getObjectsFields([key], fields);
		return data ? data[0] : null;
	};

	module.getObjectsFields = async function (keys, fields) {
		if (!Array.isArray(keys) || !keys.length) {
			return [];
		}

		const cachedData = await cache.getMany(keys, async (unCachedKeys) => {
			const res = await module.pool.query({
				name: 'getObjectsFields',
				text: `
SELECT h."data"
  FROM UNNEST($1::TEXT[]) WITH ORDINALITY k("_key", i)
  LEFT OUTER JOIN "legacy_object_live" o
               ON o."_key" = k."_key"
  LEFT OUTER JOIN "legacy_hash" h
               ON o."_key" = h."_key"
              AND o."type" = h."type"
 ORDER BY k.i ASC`,
				values: [unCachedKeys],
			});
			const data = res.rows.map(row => row.data);
			return data;
		});

		if (!Array.isArray(fields) || !fields.length) {
			return cachedData.map(data => (data ? { ...data } : null));
		}
		return cachedData.map((data) => {
			const item = data || {};
			const result = {};
			fields.forEach((field) => {
				result[field] = item[field] !== undefined ? item[field] : null;
			});
			return result;
		});
	};

	module.getObjectKeys = async function (key) {
		if (!key) {
			return;
		}

		const res = await module.pool.query({
			name: 'getObjectKeys',
			text: `
SELECT ARRAY(SELECT jsonb_object_keys(h."data")) k
  FROM "legacy_object_live" o
 INNER JOIN "legacy_hash" h
         ON o."_key" = h."_key"
        AND o."type" = h."type"
 WHERE o."_key" = $1::TEXT
 LIMIT 1`,
			values: [key],
		});

		return res.rows.length ? res.rows[0].k : [];
	};

	module.getObjectValues = async function (key) {
		const data = await module.getObject(key);
		return data ? Object.values(data) : [];
	};

	module.isObjectField = async function (key, field) {
		if (!key) {
			return;
		}

		const res = await module.pool.query({
			name: 'isObjectField',
			text: `
SELECT (h."data" ? $2::TEXT AND h."data"->>$2::TEXT IS NOT NULL) b
  FROM "legacy_object_live" o
 INNER JOIN "legacy_hash" h
         ON o."_key" = h."_key"
        AND o."type" = h."type"
 WHERE o."_key" = $1::TEXT
 LIMIT 1`,
			values: [key, field],
		});

		return res.rows.length ? res.rows[0].b : false;
	};

	module.isObjectFields = async function (key, fields) {
		if (!key) {
			return;
		}

		const data = await module.getObjectFields(key, fields);
		if (!data) {
			return fields.map(() => false);
		}
		return fields.map(field => data.hasOwnProperty(field) && data[field] !== null);
	};

	module.deleteObjectField = async function (key, field) {
		await module.deleteObjectFields(key, Array.isArray(field) ? field : [field]);
	};

	module.deleteObjectFields = async function (key, fields) {
		if (!key || (Array.isArray(key) && !key.length) || !Array.isArray(fields) || !fields.length) {
			return;
		}

		if (Array.isArray(key)) {
			await module.pool.query({
				name: 'deleteObjectFieldsKeys',
				text: `
	UPDATE "legacy_hash"
	   SET "data" = COALESCE((SELECT jsonb_object_agg("key", "value")
								FROM jsonb_each("data")
							   WHERE "key" <> ALL ($2::TEXT[])), '{}')
	 WHERE "_key" = ANY($1::TEXT[])`,
				values: [key, fields],
			});
		} else {
			await module.pool.query({
				name: 'deleteObjectFields',
				text: `
	UPDATE "legacy_hash"
	   SET "data" = COALESCE((SELECT jsonb_object_agg("key", "value")
								FROM jsonb_each("data")
							   WHERE "key" <> ALL ($2::TEXT[])), '{}')
	 WHERE "_key" = $1::TEXT`,
				values: [key, fields],
			});
		}

		cache.del(key);
	};

	module.incrObjectField = async function (key, field) {
		return await module.incrObjectFieldBy(key, field, 1);
	};

	module.decrObjectField = async function (key, field) {
		return await module.incrObjectFieldBy(key, field, -1);
	};

	module.incrObjectFieldBy = async function (key, field, value) {
		value = parseInt(value, 10);

		if (!key || isNaN(value)) {
			return null;
		}

		const result = await module.transaction(async (client) => {
			if (Array.isArray(key)) {
				await helpers.ensureLegacyObjectsType(client, key, 'hash');
			} else {
				await helpers.ensureLegacyObjectType(client, key, 'hash');
			}

			const res = await client.query(Array.isArray(key) ? {
				name: 'incrObjectFieldByMulti',
				text: `
INSERT INTO "legacy_hash" ("_key", "data")
SELECT UNNEST($1::TEXT[]), jsonb_build_object($2::TEXT, $3::NUMERIC)
ON CONFLICT ("_key")
DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
RETURNING ("data"->>$2::TEXT)::NUMERIC v`,
				values: [key, field, value],
			} : {
				name: 'incrObjectFieldBy',
				text: `
INSERT INTO "legacy_hash" ("_key", "data")
VALUES ($1::TEXT, jsonb_build_object($2::TEXT, $3::NUMERIC))
ON CONFLICT ("_key")
DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
RETURNING ("data"->>$2::TEXT)::NUMERIC v`,
				values: [key, field, value],
			});

			return Array.isArray(key) ?
				res.rows.map(r => parseFloat(r.v)) :
				parseFloat(res.rows[0].v);
		});
		cache.del(key);
		return result;
	};

	module.incrObjectFieldByBulk = async function (data) {
		if (!Array.isArray(data) || !data.length) {
			return;
		}
		const keys = data.map(item => item[0]);
		await module.transaction(async (client) => {
			await helpers.ensureLegacyObjectsType(client, keys, 'hash');

			const dataStrings = data.map(item => JSON.stringify(item[1]));

			await client.query({
				name: 'incrObjectFieldByBulk',
				text: `
INSERT INTO "legacy_hash" ("_key", "data")
SELECT k, d
FROM UNNEST($1::TEXT[], $2::JSONB[]) vs(k, d)
ON CONFLICT ("_key")
DO UPDATE SET "data" = (
    SELECT jsonb_object_agg(
        key,
        CASE
            WHEN jsonb_typeof(legacy_hash.data -> key) = 'number'
                 AND jsonb_typeof(EXCLUDED.data -> key) = 'number'
            THEN to_jsonb((legacy_hash.data ->> key)::NUMERIC + (EXCLUDED.data ->> key)::NUMERIC)
            ELSE COALESCE(EXCLUDED.data -> key, legacy_hash.data -> key)
        END
    )
    FROM jsonb_each(legacy_hash.data || EXCLUDED.data) AS merged(key, value)
);`,
				values: [keys, dataStrings],
			});
		});
		cache.del(keys);
	};
};