@genoacms/adapter-gcp 0.10.0 → 0.11.0

package/dist/database/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { Adapter } from '@genoacms/contracts/database';
+import { type Adapter } from '@genoacms/contracts/database';
 import type { GcpDatabaseOptions } from './descriptor.js';
 /** One Firestore provider, with its own client and credential. */
 declare const _default: import("@genoacms/contracts").AdapterRuntime<GcpDatabaseOptions, Adapter>;

package/dist/database/runtime.js

@@ -1,5 +1,117 @@
+import { DocumentNotFoundError, UnsupportedQueryError } from '@genoacms/contracts/database';
+import { checkQuery, checkValues, decodeToken, encodeToken, matches } from '@genoacms/contracts/database/query';
 import { defineRuntime } from '@genoacms/contracts';
-import { Firestore } from '@google-cloud/firestore';
+import { FieldPath, Firestore } from '@google-cloud/firestore';
+const MAXIMUM_ID_BYTES = 1500;
+const FAILED_PRECONDITION = 9;
+const NOT_FOUND = 5;
+// DATA-2
+const asJson = (data) => JSON.parse(JSON.stringify(data));
+// DATA-3
+const withKey = (collection, id, data) => {
+    const keyed = { ...data, [collection.primaryKey.key]: id };
+    return keyed;
+};
+const snapshotOf = (collection, document) => ({ reference: { collection, id: document.id }, data: withKey(collection, document.id, document.data()) });
+const errorCode = (error) => error?.code;
+const isInequality = ({ operator }) => operator !== '==';
+// DATA-5
+const isStorableId = (id) => id !== '' && !id.includes('/') && id !== '.' && id !== '..' && !/^__.*__$/.test(id) && Buffer.byteLength(id) <= MAXIMUM_ID_BYTES;
+// DATA-9
+const isUnstorableKeyCondition = (collection, { field, value }) => field === collection.primaryKey.key && typeof value === 'string' && !isStorableId(value);
+// DATA-9
+const matchesNothing = (collection, conditions) => conditions.some(condition => {
+    const { field, operator, value } = condition;
+    return (field === collection.primaryKey.key && typeof value !== 'string') ||
+        (value === null && operator !== '==') ||
+        (isUnstorableKeyCondition(collection, condition) && operator === '==');
+});
+// DATA-9
+const withoutVacuousConditions = (collection, conditions) => conditions.filter(condition => !(isUnstorableKeyCondition(collection, condition) && condition.operator === '!='));
+// DATA-9
+const sentToStore = (collection, conditions) => conditions.filter(condition => !isUnstorableKeyCondition(collection, condition));
+const fieldPathOf = (collection, field) => field === collection.primaryKey.key ? FieldPath.documentId() : new FieldPath(field);
+// DB-5
+const inequalityFields = (collection, conditions) => [...new Set(conditions.filter(isInequality).map(({ field }) => field))]
+    .filter(field => field !== collection.primaryKey.key)
+    .sort();
+const filteredQuery = (query, collection, conditions) => conditions.reduce((filtered, { field, operator, value }) => filtered.where(fieldPathOf(collection, field), operator, value), query);
+const orderedQuery = (query, fields) => [...fields.map(field => new FieldPath(field)), FieldPath.documentId()].reduce((ordered, field) => ordered.orderBy(field), query);
+const cursorAfter = (fields, document, collection) => {
+    const data = withKey(collection, document.id, document.data());
+    return { values: fields.map(field => data[field]), id: document.id };
+};
+const batchQuery = ({ base, limit, fields }, token) => {
+    const resumed = token === undefined ? base : base.startAfter(...cursorValues(token, fields));
+    return limit === undefined ? resumed : resumed.limit(limit);
+};
+async function fetchBatch(query) {
+    const fetched = [];
+    const result = await query.get().catch(refuseUnservableQuery);
+    result.forEach(document => { fetched.push(document); });
+    return fetched;
+}
+// DATA-11
+function refuseUnservableQuery(error) {
+    if (errorCode(error) === FAILED_PRECONDITION && /index/i.test(error.message))
+        throw new UnsupportedQueryError(error.message);
+    throw error;
+}
+// DATA-8
+function cursorValues(token, fields) {
+    const cursor = decodeToken(token);
+    if (typeof cursor?.id !== 'string' || !Array.isArray(cursor.values) || cursor.values.length !== fields.length)
+        throw new Error('database/invalid-query: unknown page token');
+    return [...cursor.values, cursor.id];
+}
+// DATA-10
+function pageAtLimit(scan, batch, documents) {
+    for (const [index, document] of batch.entries()) {
+        const snapshot = snapshotOf(scan.collection, document);
+        if (!matches(snapshot.data, scan.conditions))
+            continue;
+        documents.push(snapshot);
+        if (documents.length !== scan.limit)
+            continue;
+        const queryMayHaveMore = index < batch.length - 1 || batch.length === scan.limit;
+        return queryMayHaveMore ? { documents, next: encodeToken(cursorAfter(scan.fields, document, scan.collection)) } : { documents };
+    }
+    return undefined;
+}
+// DATA-10
+async function pageOf(scan, firstToken) {
+    const documents = [];
+    let token = firstToken;
+    for (;;) {
+        const batch = await fetchBatch(batchQuery(scan, token));
+        const page = pageAtLimit(scan, batch, documents);
+        if (page !== undefined)
+            return page;
+        if (scan.limit === undefined || batch.length < scan.limit)
+            return { documents };
+        token = encodeToken(cursorAfter(scan.fields, batch[batch.length - 1], scan.collection));
+    }
+}
+async function requireExisting(document, reference) {
+    if (!(await document.get()).exists)
+        throw new DocumentNotFoundError(reference);
+}
+// DATA-3
+function withoutKeyField(collection, data) {
+    const { [collection.primaryKey.key]: _key, ...rest } = data;
+    return rest;
+}
+// DATA-3
+function withoutIgnoredKey(reference, data) {
+    const key = reference.collection.primaryKey.key;
+    if (data[key] !== undefined && data[key] !== reference.id)
+        throw new Error(`database/key-immutable: ${key}`);
+    return withoutKeyField(reference.collection, data);
+}
+// DATA-6
+const updateArguments = (fields) => Object.entries(fields)
+    .filter(([, value]) => value !== undefined)
+    .flatMap(([field, value]) => [new FieldPath(field), asJson(value)]);
 /** One Firestore provider, with its own client and credential. */
 export default defineRuntime({
     create({ projectId, databaseId, credentials }) {
@@ -9,52 +121,65 @@ export default defineRuntime({
             ...(credentials === undefined ? {} : { credentials })
         });
         const createDocument = async (reference, data) => {
-            const document = await firestore.collection(reference.name).add(data);
+            const given = withoutKeyField(reference, data);
+            checkValues(given);
+            const document = firestore.collection(reference.name).doc();
+            const stored = withKey(reference, document.id, given);
+            await document.set(asJson(stored));
             const documentReference = {
                 collection: reference,
                 id: document.id
             };
             return {
                 reference: documentReference,
-                data
+                data: stored
             };
         };
-        const getCollection = async (reference) => {
-            const collection = await firestore.collection(reference.name).get();
-            const documents = [];
-            collection.forEach(document => {
-                documents.push({
-                    reference: {
-                        collection: reference,
-                        id: document.id
-                    },
-                    data: document.data()
-                });
-            });
-            return documents;
+        const getCollection = async (reference, params = {}) => {
+            checkQuery(params);
+            const conditions = withoutVacuousConditions(reference, params.where ?? []);
+            const queried = sentToStore(reference, conditions);
+            const fields = inequalityFields(reference, queried);
+            const firstToken = params.pageToken;
+            if (firstToken !== undefined)
+                cursorValues(firstToken, fields);
+            if (matchesNothing(reference, conditions))
+                return { documents: [] };
+            const base = orderedQuery(filteredQuery(firestore.collection(reference.name), reference, queried), fields);
+            return await pageOf({ base, collection: reference, conditions, fields, limit: params.limit }, firstToken);
         };
         const getDocument = async ({ collection, id }) => {
+            if (!isStorableId(id))
+                return undefined;
             const document = await firestore.collection(collection.name).doc(id).get();
             if (!document.exists)
                 return undefined;
-            const documentReference = {
-                collection,
-                id
-            };
-            const documentSnapshot = {
-                reference: documentReference,
-                data: document.data()
-            };
-            return documentSnapshot;
+            return { reference: { collection, id }, data: withKey(collection, id, document.data()) };
         };
-        const updateDocument = async (reference, document) => {
-            await firestore.collection(reference.collection.name).doc(reference.id).update(document);
-            return {
-                reference,
-                data: document
-            };
+        const updateDocument = async (reference, data) => {
+            const given = withoutIgnoredKey(reference, data);
+            checkValues(given);
+            if (!isStorableId(reference.id))
+                throw new DocumentNotFoundError(reference);
+            const [field, value, ...rest] = updateArguments(given);
+            const document = firestore.collection(reference.collection.name).doc(reference.id);
+            try {
+                if (field === undefined)
+                    await requireExisting(document, reference);
+                else
+                    await document.update(field, value, ...rest);
+            }
+            catch (error) {
+                if (errorCode(error) === NOT_FOUND)
+                    throw new DocumentNotFoundError(reference);
+                throw error;
+            }
+            const snapshot = { reference, data };
+            return snapshot;
         };
         const deleteDocument = async (reference) => {
+            if (!isStorableId(reference.id))
+                return;
             await firestore.collection(reference.collection.name).doc(reference.id).delete();
         };
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genoacms/adapter-gcp",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "description": "Implementation of abstraction layer of GenoaCMS for GCP",
   "repository": {
@@ -27,7 +27,7 @@
     "@google-cloud/storage": "^7.7.0",
     "archiver": "^7.0.0",
     "google-auth-library": "^9.15.1",
-    "@genoacms/contracts": "^0.0.3",
+    "@genoacms/contracts": "^0.1.0",
     "@genoacms/sveltekit-adapter-cloud-run-functions": "^1.0.1"
   },
   "devDependencies": {
@@ -41,7 +41,7 @@
     "rimraf": "^5.0.5",
     "typescript": "^5.2.2",
     "vitest": "^3.2.7",
-    "@genoacms/conformance": "^0.0.3"
+    "@genoacms/conformance": "^0.1.0"
   },
   "files": [
     "dist"