use DB uuid type for entity uuids: straightforward type casts

Author: brontolosone

lib/model/query/audits.js

@@ -154,7 +154,7 @@ const getBySubmissionId = (submissionId, options) => ({ all }) => _getBySubmissi
 const _getByEntityId = (fields, options, entityId) => sql`
 SELECT ${fields} FROM (
     SELECT audits.* FROM audits 
-    JOIN entities ON (audits.details->'entity'->>'uuid') = entities.uuid
+    JOIN entities ON (audits.details->'entity'->>'uuid')::uuid = entities.uuid
     WHERE entities.id = ${entityId}
     UNION ALL
     SELECT audits.* FROM audits

lib/model/query/entities.js

@@ -25,16 +25,16 @@ const { PURGE_DAY_RANGE } = require('../../util/constants');
 // Check if provided UUIDs (array) were used by purged entities.
 
 const _getPurgedOrDeletedUuids = (all, uuids) => all(sql`
-    SELECT "entityUuid" AS uuid FROM purged_entities WHERE "entityUuid" = ANY (ARRAY[${sql.array(uuids, 'text')}])
+    SELECT "entityUuid" AS uuid FROM purged_entities WHERE "entityUuid" = ANY (ARRAY[${sql.array(uuids, 'uuid')}])
     UNION
-    SELECT uuid FROM entities WHERE "deletedAt" IS NOT NULL AND uuid = ANY (ARRAY[${sql.array(uuids, 'text')}])`)
+    SELECT uuid FROM entities WHERE "deletedAt" IS NOT NULL AND uuid = ANY (ARRAY[${sql.array(uuids, 'uuid')}])`)
   .then(all.map(r => r.uuid));
 
 const _isPurgedOrDeletedUuid = (oneFirst, uuid) => oneFirst(sql`
     SELECT
-      EXISTS ( SELECT 1 FROM purged_entities WHERE "entityUuid" = ${uuid} )
+      EXISTS ( SELECT 1 FROM purged_entities WHERE "entityUuid" = ${uuid}::uuid )
       OR
-      EXISTS ( SELECT 1 FROM entities WHERE uuid = ${uuid} AND "deletedAt" IS NOT NULL )
+      EXISTS ( SELECT 1 FROM entities WHERE uuid = ${uuid}::uuid AND "deletedAt" IS NOT NULL )
   `);
 /////////////////////////////////////////////////////////////////////////////////
 // ENTITY DEF SOURCES
@@ -113,7 +113,7 @@ const createNew = (dataset, partial, subDef, sourceId, userAgentIn) => async ({
   return one(sql`
 with def as (${_defInsert(nextval, true, creatorId, userAgent, partial, 1, sourceId)}),
 ins as (insert into entities (id, "datasetId", "uuid", "createdAt", "creatorId")
-  select def."entityId", ${dataset.id}, ${partial.uuid}, def."createdAt", ${creatorId} from def
+  select def."entityId", ${dataset.id}, ${partial.uuid}::uuid, def."createdAt", ${creatorId} from def
   returning entities.*)
 select ins.*, def.id as "entityDefId" from ins, def;`)
     .then(({ entityDefId, ...entityData }) =>
@@ -197,7 +197,7 @@ const createVersion = (dataset, partial, subDef, version, sourceId, baseVersion,
   with def as (${_defInsert(partial.id, false, creatorId, userAgent, partial, version, sourceId, baseVersion, conflictingPropJson)}),
   upd as (update entity_defs set current=false where entity_defs."entityId" = ${partial.id} AND current IS TRUE),
   entities as (update entities set "updatedAt"=clock_timestamp(), conflict=${partial.conflict ?? sql`NULL`}
-    where "uuid"=${partial.uuid}
+    where "uuid"=${partial.uuid}::uuid
     returning *)
   select ${_unjoiner.fields} from def as entity_defs
   join entities on entity_defs."entityId" = entities.id
@@ -677,7 +677,7 @@ const _holdSubmission = (event, submissionId, submissionDefId, entityUuid, branc
   await Entities.logBacklogEvent('hold', event, submissionId, submissionDefId);
   await run(sql`
   INSERT INTO entity_submission_backlog ("auditId", "submissionId", "submissionDefId", "entityUuid", "branchId", "branchBaseVersion", "loggedAt")
-  VALUES (${event.id}, ${submissionId}, ${submissionDefId}, ${entityUuid}, ${branchId}, ${branchBaseVersion}, CLOCK_TIMESTAMP())
+  VALUES (${event.id}, ${submissionId}, ${submissionDefId}, ${entityUuid}::uuid, ${branchId}, ${branchBaseVersion}, CLOCK_TIMESTAMP())
   `);
 };
 
@@ -691,7 +691,7 @@ const _getNextHeldSubmissionInBranch = (entityUuid, branchId, branchBaseVersion)
   (branchId == null)
     ? maybeOne(sql`
       SELECT * FROM entity_submission_backlog
-      WHERE "entityUuid" = ${entityUuid} AND "branchBaseVersion" = 1`)
+      WHERE "entityUuid" = ${entityUuid}::uuid AND "branchBaseVersion" = 1`)
     : maybeOne(sql`
       SELECT * FROM entity_submission_backlog
       WHERE "branchId"=${branchId} AND "branchBaseVersion" = ${branchBaseVersion}`));
@@ -868,7 +868,7 @@ INNER JOIN entities ON entities.id = entity_defs."entityId"
 LEFT JOIN actors ON entities."creatorId"=actors.id
 ${options.skiptoken ? sql`
   INNER JOIN
-  ( SELECT id, "createdAt" FROM entities WHERE "uuid" = ${options.skiptoken.uuid}) AS cursor
+  ( SELECT id, "createdAt" FROM entities WHERE "uuid" = ${options.skiptoken.uuid}::uuid) AS cursor
   ON entities."createdAt" <= cursor."createdAt" AND entities.id < cursor.id
   `: sql``} 
 WHERE
@@ -903,7 +903,7 @@ CROSS JOIN
   JOIN entity_defs ON entity_defs."entityId" = entities.id
   ${options.skiptoken ? sql`
   INNER JOIN
-  ( SELECT id, "createdAt" FROM entities WHERE "uuid" = ${options.skiptoken.uuid}) AS cursor
+  ( SELECT id, "createdAt" FROM entities WHERE "uuid" = ${options.skiptoken.uuid}::uuid) AS cursor
   ON entities."createdAt" <= cursor."createdAt" AND entities.id < cursor.id
   `: sql``} 
   WHERE "datasetId" = ${datasetId}
@@ -958,7 +958,7 @@ const _trashedFilter = (force, projectId, datasetName, entityUuid) => {
   const idFilters = [sql`TRUE`];
   if (projectId) idFilters.push(sql`datasets."projectId" = ${projectId}`);
   if (datasetName) idFilters.push(sql`datasets."name" = ${datasetName}`);
-  if (entityUuid) idFilters.push(sql`entities."uuid" = ${entityUuid}`);
+  if (entityUuid) idFilters.push(sql`entities."uuid" = ${entityUuid}::uuid`);
 
   const idFilter = sql.join(idFilters, sql` AND `);
 
@@ -984,7 +984,7 @@ const purge = (force = false, projectId = null, datasetName = null, entityUuid =
       UPDATE audits SET notes = NULL
       FROM entities
       JOIN datasets ON entities."datasetId" = datasets.id
-      WHERE (audits.details->'entity'->>'uuid') = entities.uuid
+      WHERE (audits.details->'entity'->>'uuid')::uuid = entities.uuid
       AND ${_trashedFilter(force, projectId, datasetName, entityUuid)}
     ), purge_audit AS (
       INSERT INTO audits ("action", "acteeId", "loggedAt", "processed", "details")
@@ -1005,7 +1005,7 @@ const purge = (force = false, projectId = null, datasetName = null, entityUuid =
     ), delete_submission_backlog AS (
       DELETE FROM entity_submission_backlog
       USING entities, datasets
-      WHERE entity_submission_backlog."entityUuid"::varchar = entities.uuid
+      WHERE entity_submission_backlog."entityUuid"::uuid = entities.uuid
       AND entities."datasetId" = datasets.id
       AND ${_trashedFilter(force, projectId, datasetName, entityUuid)} 
     ), deleted_entities AS (
@@ -1060,7 +1060,7 @@ order by actors."displayName" asc`)
   .then(map(construct(Actor)));
 
 const deleteByIds = (uuids) => ({ allFirst }) => allFirst(sql`
-  UPDATE entities SET "deletedAt" = now() WHERE "deletedAt" IS NULL AND uuid = ANY (ARRAY[${sql.array(uuids, 'text')}])
+  UPDATE entities SET "deletedAt" = now() WHERE "deletedAt" IS NULL AND uuid = ANY (ARRAY[${sql.array(uuids, 'uuid')}])
   RETURNING uuid
 `);
 
@@ -1077,7 +1077,7 @@ deleteByIds.audit = (deletedUuids, _, dataset) => (log) => {
 deleteByIds.audit.withResult = true;
 
 const restoreByIds = (uuids) => ({ allFirst }) => allFirst(sql`
-  UPDATE entities SET "deletedAt" = null WHERE "deletedAt" IS NOT NULL AND uuid = ANY (ARRAY[${sql.array(uuids, 'text')}])
+  UPDATE entities SET "deletedAt" = null WHERE "deletedAt" IS NOT NULL AND uuid = ANY (ARRAY[${sql.array(uuids, 'uuid')}])
   RETURNING uuid
 `);