Node.js based forum software built for the modern web
'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);
};
};