@genoacms/adapter-gcp 0.9.0 → 0.11.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2026 Filip Holčík
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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/dist/storage/runtime.js

@@ -1,18 +1,35 @@
 import { defineRuntime } from '@genoacms/contracts';
-import { PreconditionFailedError } from '@genoacms/contracts/storage';
+import { PreconditionFailedError, ObjectNotFoundError, NotADirectoryError, isDirectoryName } from '@genoacms/contracts/storage';
 import { Storage } from '@google-cloud/storage';
 const HTTP_PRECONDITION_FAILED = 412;
+const HTTP_NOT_FOUND = 404;
 const DELETE_CONCURRENCY = 10;
-// STO-9, GF21
-function requestedResults(limit, startAfter) {
-    return limit !== undefined && startAfter !== undefined ? limit + 1 : limit;
+const hasStatus = (error, status) => error?.code === status;
+// STO-4, STO-7, STOR-16
+async function rejectingMissing(reference, call) {
+    try {
+        return await call();
+    }
+    catch (error) {
+        if (hasStatus(error, HTTP_NOT_FOUND))
+            throw new ObjectNotFoundError(reference);
+        throw error;
+    }
 }
 // STO-9
-const byUtf8Bytes = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b));
-// STO-9
-function firstByName(names, limit) {
-    const sorted = [...names].sort(byUtf8Bytes);
-    return new Set(limit === undefined ? sorted : sorted.slice(0, limit));
+function listingQuery(name, { limit, startAfter, pageToken }) {
+    return {
+        prefix: name,
+        delimiter: '/',
+        autoPaginate: false,
+        ...(limit === undefined ? {} : { maxResults: limit }),
+        ...(startAfter === undefined ? {} : { startOffset: startAfter }),
+        ...(pageToken === undefined ? {} : { pageToken })
+    };
+}
+// STO-11, GF38
+function everyDepthPage(prefix, pageToken) {
+    return pageToken === undefined ? { prefix, autoPaginate: false } : { prefix, autoPaginate: false, pageToken };
 }
 // STO-11, GF29
 async function deleteAtMost(concurrency, files) {
@@ -46,6 +63,16 @@ export default defineRuntime({
                 throw new Error('bucket-unregistered');
             return storage.bucket(name);
         };
+        // STO-3, STOR-3
+        const requireDirectoryName = (reference, { allowRoot }) => {
+            if (!isDirectoryName(reference.name) || (!allowRoot && reference.name === ''))
+                throw new NotADirectoryError(reference);
+        };
+        const getDirectoryBucket = (reference, options) => {
+            const bucketInstance = getBucket(reference.bucket);
+            requireDirectoryName(reference, options);
+            return bucketInstance;
+        };
         // STO-4
         const getObject = async ({ bucket, name }) => {
             const bucketInstance = getBucket(bucket);
@@ -55,7 +82,9 @@ export default defineRuntime({
                 const [metadata] = await file.getMetadata();
                 version = metadata.generation === undefined ? undefined : String(metadata.generation);
             }
-            catch {
+            catch (error) {
+                if (hasStatus(error, HTTP_NOT_FOUND))
+                    throw new ObjectNotFoundError({ bucket, name });
                 version = undefined;
             }
             return {
@@ -80,16 +109,16 @@ export default defineRuntime({
         const uploadObject = async ({ bucket, name }, stream, options) => {
             const bucketInstance = getBucket(bucket);
             const file = bucketInstance.file(name);
-            const { ifVersion, ifAbsent, ...saveOptions } = options ?? {};
+            const { ifVersion, ifAbsent } = options ?? {};
             // STO-6
             const generation = ifAbsent === true ? 0 : ifVersion === undefined ? undefined : Number(ifVersion);
             try {
                 await file.save(stream, generation === undefined
-                    ? saveOptions
-                    : { ...saveOptions, preconditionOpts: { ifGenerationMatch: generation } });
+                    ? {}
+                    : { preconditionOpts: { ifGenerationMatch: generation } });
             }
             catch (error) {
-                if (error.code === HTTP_PRECONDITION_FAILED) {
+                if (hasStatus(error, HTTP_PRECONDITION_FAILED)) {
                     throw new PreconditionFailedError({ bucket, name }, ifAbsent === true
                         ? 'object already exists'
                         : 'object changed since it was read');
@@ -105,26 +134,22 @@ export default defineRuntime({
         const deleteObject = async ({ bucket, name }) => {
             const bucketInstance = getBucket(bucket);
             const file = bucketInstance.file(name);
-            await file.delete();
+            await rejectingMissing({ bucket, name }, async () => await file.delete());
         };
-        const listDirectory = async ({ bucket, name }, listingParams = {}) => {
-            const bucketInstance = getBucket(bucket);
-            const options = {
-                autoPaginate: false,
-                prefix: name,
-                maxResults: requestedResults(listingParams?.limit, listingParams?.startAfter),
-                startOffset: listingParams?.startAfter,
-                delimiter: '/'
-            };
-            let [files, , apiResponse] = (await bucketInstance.getFiles(options));
-            files = files.filter((file) => !file.name.endsWith('.folderPlaceholder'));
-            // STO-9, GF21
-            const skipped = (itemName) => itemName === name || itemName === listingParams?.startAfter;
-            files = files.filter(f => !skipped(f.name));
-            const prefixes = (apiResponse?.prefixes ?? []).filter((item) => !skipped(item));
-            const kept = firstByName([...files.map(f => f.name), ...prefixes], listingParams?.limit);
+        // STO-9, GF21
+        const listDirectory = async (reference, listingParams = {}) => {
+            const bucketInstance = getDirectoryBucket(reference, { allowRoot: true });
+            const { bucket, name } = reference;
+            if (listingParams.limit === 0)
+                return { files: [], directories: [] };
+            const [listed, nextQuery, apiResponse] = (await bucketInstance.getFiles(listingQuery(name, listingParams)));
+            const skipped = (itemName) => itemName === name || itemName === listingParams.startAfter;
+            const files = listed.filter(file => !file.name.endsWith('.folderPlaceholder') && !skipped(file.name));
+            const prefixes = (apiResponse?.prefixes ?? []).filter(item => !skipped(item));
+            const next = nextQuery?.pageToken;
             return {
-                files: files.filter(f => kept.has(f.name)).map((file) => {
+                ...(next === undefined ? {} : { next }),
+                files: files.map((file) => {
                     return {
                         name: file.name,
                         // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
@@ -132,7 +157,7 @@ export default defineRuntime({
                         lastModified: new Date(file.metadata.updated)
                     };
                 }),
-                directories: prefixes.filter((item) => kept.has(item)).map(i => {
+                directories: prefixes.map(i => {
                     const object = {
                         bucket,
                         name: i
@@ -141,24 +166,28 @@ export default defineRuntime({
                 })
             };
         };
-        const createDirectory = async ({ bucket, name }) => {
-            const bucketInstance = getBucket(bucket);
-            const file = bucketInstance.file(`${name}/.folderPlaceholder`);
+        // STO-10, CD10
+        const createDirectory = async (reference) => {
+            const bucketInstance = getDirectoryBucket(reference, { allowRoot: false });
+            const file = bucketInstance.file(`${reference.name}.folderPlaceholder`);
             await file.save('');
         };
         // STO-11, GD7, GF29
-        const deleteDirectory = async ({ bucket, name }) => {
-            const bucketInstance = getBucket(bucket);
-            let query = { prefix: name, autoPaginate: false };
-            while (query !== undefined) {
-                const [files, nextQuery] = await bucketInstance.getFiles(query);
+        const deleteDirectory = async (reference) => {
+            const bucketInstance = getDirectoryBucket(reference, { allowRoot: false });
+            let pageToken;
+            do {
+                const [files, nextQuery] = await bucketInstance.getFiles(everyDepthPage(reference.name, pageToken));
                 await deleteAtMost(DELETE_CONCURRENCY, files);
-                query = nextQuery ?? undefined;
-            }
+                pageToken = nextQuery?.pageToken;
+            } while (pageToken !== undefined);
         };
         // STO-12, GD7, GF22
-        const moveDirectory = async ({ bucket, name }, newName) => {
-            const [files] = await getBucket(bucket).getFiles({ prefix: name });
+        const moveDirectory = async (reference, newName) => {
+            const bucketInstance = getDirectoryBucket(reference, { allowRoot: false });
+            requireDirectoryName({ bucket: reference.bucket, name: newName }, { allowRoot: false });
+            const { name } = reference;
+            const [files] = await bucketInstance.getFiles({ prefix: name });
             for (const file of files)
                 await file.move(newName + file.name.slice(name.length));
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genoacms/adapter-gcp",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "type": "module",
   "description": "Implementation of abstraction layer of GenoaCMS for GCP",
   "repository": {
@@ -12,7 +12,7 @@
     "name": "Filip Holčík",
     "email": "filip.holcik.official@gmail.com"
   },
-  "license": "ISC",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/GenoaCMS/genoacms/issues"
   },
@@ -27,7 +27,7 @@
     "@google-cloud/storage": "^7.7.0",
     "archiver": "^7.0.0",
     "google-auth-library": "^9.15.1",
-    "@genoacms/contracts": "^0.0.2",
+    "@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.2"
+    "@genoacms/conformance": "^0.1.0"
   },
   "files": [
     "dist"