@adobe/spacecat-shared-data-access 2.108.0 → 3.0.0

package/src/util/postgrest.utils.js

@@ -0,0 +1,203 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import pluralize from 'pluralize';
+
+const DEFAULT_PAGE_SIZE = 1000;
+
+const ENTITY_TABLE_OVERRIDES = {
+  LatestAudit: 'audits',
+};
+
+const camelToSnake = (value) => value.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+
+const snakeToCamel = (value) => value.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+
+const entityToTableName = (entityName) => {
+  const override = ENTITY_TABLE_OVERRIDES[entityName];
+  if (override) {
+    return override;
+  }
+  return camelToSnake(pluralize.plural(entityName));
+};
+
+const encodeCursor = (offset) => Buffer.from(JSON.stringify({ offset }), 'utf-8').toString('base64');
+
+const decodeCursor = (cursor) => {
+  if (!cursor) {
+    return 0;
+  }
+
+  try {
+    const decoded = JSON.parse(Buffer.from(cursor, 'base64').toString('utf-8'));
+    return Number.isInteger(decoded.offset) && decoded.offset >= 0 ? decoded.offset : 0;
+  } catch (e) {
+    return 0;
+  }
+};
+
+const createFieldMaps = (schema) => {
+  const toDbMap = {};
+  const toModelMap = {};
+  const attributes = schema.getAttributes();
+  const idName = typeof schema.getIdName === 'function' ? schema.getIdName() : undefined;
+  Object.keys(attributes).forEach((modelField) => {
+    const attribute = attributes[modelField] || {};
+    if (attribute.postgrestIgnore) {
+      return;
+    }
+    const dbField = attribute.postgrestField
+      || (modelField === idName && modelField !== 'id' ? 'id' : camelToSnake(modelField));
+    toDbMap[modelField] = dbField;
+    toModelMap[dbField] = modelField;
+  });
+
+  const idAttribute = idName ? attributes[idName] : undefined;
+  if (idName
+    && idName !== 'id'
+    && idAttribute
+    && !idAttribute.postgrestIgnore) {
+    toDbMap[idName] = 'id';
+    toModelMap.id = idName;
+  }
+
+  return { toDbMap, toModelMap };
+};
+
+const toDbField = (field, map) => map[field] || camelToSnake(field);
+
+const toModelField = (field, map) => map[field] || snakeToCamel(field);
+
+const toDbRecord = (record, toDbMap, options = {}) => {
+  const { includeUnknown = false } = options;
+  return Object.entries(record).reduce((acc, [key, value]) => {
+    if (Object.prototype.hasOwnProperty.call(toDbMap, key)) {
+      acc[toDbMap[key]] = value;
+      return acc;
+    }
+
+    if (includeUnknown) {
+      acc[toDbField(key, toDbMap)] = value;
+    }
+
+    return acc;
+  }, {});
+};
+
+const looksLikeIsoDateTime = (value) => typeof value === 'string'
+  && /^\d{4}-\d{2}-\d{2}T/.test(value)
+  && /(?:Z|[+-]\d{2}:\d{2})$/.test(value);
+
+const normalizeModelValue = (value) => {
+  if (value === null) {
+    return undefined;
+  }
+
+  // PostgREST can return jsonb null scalars as [null] for some projections/aggregations.
+  // We normalize this artifact to "missing" so model payloads match v2 behavior.
+  if (Array.isArray(value) && value.length === 1 && value[0] === null) {
+    return undefined;
+  }
+
+  if (looksLikeIsoDateTime(value)) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date.toISOString();
+    }
+  }
+
+  return value;
+};
+
+const fromDbRecord = (record, toModelMap) => Object.entries(record).reduce((acc, [key, value]) => {
+  const normalized = normalizeModelValue(value);
+  if (normalized !== undefined) {
+    acc[toModelField(key, toModelMap)] = normalized;
+  }
+  return acc;
+}, {});
+
+const applyWhere = (query, whereFn, toDbMap) => {
+  if (typeof whereFn !== 'function') {
+    return query;
+  }
+
+  const attrs = new Proxy({}, {
+    get: (_, prop) => toDbField(String(prop), toDbMap),
+  });
+
+  const op = {
+    eq: (field, value) => ({ type: 'eq', field, value }),
+    ne: (field, value) => ({ type: 'ne', field, value }),
+    gt: (field, value) => ({ type: 'gt', field, value }),
+    gte: (field, value) => ({ type: 'gte', field, value }),
+    lt: (field, value) => ({ type: 'lt', field, value }),
+    lte: (field, value) => ({ type: 'lte', field, value }),
+    in: (field, value) => ({ type: 'in', field, value }),
+    is: (field, value) => ({ type: 'is', field, value }),
+    like: (field, value) => ({ type: 'like', field, value }),
+    ilike: (field, value) => ({ type: 'ilike', field, value }),
+    contains: (field, value) => ({ type: 'contains', field, value }),
+  };
+
+  const expression = whereFn(attrs, op);
+  if (!expression || typeof expression !== 'object') {
+    return query;
+  }
+
+  switch (expression.type) {
+    case 'eq':
+      return query.eq(expression.field, expression.value);
+    case 'ne':
+      return query.neq(expression.field, expression.value);
+    case 'gt':
+      return query.gt(expression.field, expression.value);
+    case 'gte':
+      return query.gte(expression.field, expression.value);
+    case 'lt':
+      return query.lt(expression.field, expression.value);
+    case 'lte':
+      return query.lte(expression.field, expression.value);
+    case 'in':
+      return query.in(
+        expression.field,
+        Array.isArray(expression.value) ? expression.value : [expression.value],
+      );
+    case 'is':
+      return query.is(expression.field, expression.value);
+    case 'like':
+      return query.like(expression.field, expression.value);
+    case 'ilike':
+      return query.ilike(expression.field, expression.value);
+    case 'contains': {
+      const value = Array.isArray(expression.value) ? expression.value : [expression.value];
+      return query.contains(expression.field, value);
+    }
+    default:
+      throw new Error(`Unsupported where operator: ${expression.type}`);
+  }
+};
+
+export {
+  DEFAULT_PAGE_SIZE,
+  applyWhere,
+  camelToSnake,
+  createFieldMaps,
+  decodeCursor,
+  encodeCursor,
+  entityToTableName,
+  fromDbRecord,
+  snakeToCamel,
+  toDbField,
+  toDbRecord,
+  toModelField,
+};

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "test"]
+}