@dereekb/firebase-server 12.4.4 → 12.5.0

package/model/src/lib/storagefile/storagefile.upload.service.d.ts

@@ -0,0 +1,57 @@
+import { FirebaseStorageAccessorFile, StorageFileDocument, StorageFileInitializeFromUploadResultType, UploadedFileTypeDeterminerResult } from '@dereekb/firebase';
+import { Maybe, PromiseOrValue } from '@dereekb/util';
+/**
+ * Provides a reference to a StorageFileInitializeFromUploadService instance.
+ */
+export interface StorageFileInitializeFromUploadServiceRef {
+    readonly storageFileInitializeFromUploadService: StorageFileInitializeFromUploadService;
+}
+export interface StorageFileInitializeFromUploadInput {
+    /**
+     * The target file.
+     *
+     * This file should not be modified (e.g. deleted) during the processor call.
+     */
+    readonly file: FirebaseStorageAccessorFile;
+}
+export interface StorageFileInitializeFromUploadResult {
+    /**
+     * Whether or not the initialization was successful.
+     */
+    readonly resultType: StorageFileInitializeFromUploadResultType;
+    /**
+     * The initialized StorageFile value, if applicable.
+     */
+    readonly storageFileDocument?: Maybe<StorageFileDocument>;
+    /**
+     * Any error that occurred during processing.
+     */
+    readonly initializationError?: Maybe<unknown>;
+    /**
+     * Number of StorageFiles that were flagged for deletion.
+     *
+     * Only set if flagPreviousForDelete was provided.
+     */
+    readonly previousStorageFilesFlaggedForDeletion?: Maybe<number>;
+}
+/**
+ * Service dedicated to initializing a StorageFileDocument value from an uploaded file.
+ */
+export declare abstract class StorageFileInitializeFromUploadService {
+    /**
+     * Returns true if the file is allowed to be initialized.
+     *
+     * @param file
+     */
+    abstract checkFileIsAllowedToBeInitialized(file: FirebaseStorageAccessorFile): PromiseOrValue<boolean>;
+    /**
+     * Used to determine the type of the input file.
+     */
+    abstract determineUploadFileType(input: StorageFileInitializeFromUploadInput): Promise<Maybe<UploadedFileTypeDeterminerResult>>;
+    /**
+     * Initializes a StorageFileDocument value from an uploaded file.
+     *
+     * The input file is unchanged, only new content is created.
+     */
+    abstract initializeFromUpload(input: StorageFileInitializeFromUploadInput): Promise<StorageFileInitializeFromUploadResult>;
+}

package/model/src/lib/storagefile/storagefile.upload.service.initializer.d.ts

@@ -0,0 +1,105 @@
+import { CombineUploadFileTypeDeterminerConfig, CreateStorageFileDocumentPairResult, FirebaseStorageAccessorFile, StorageFileDocument, StorageFileFirestoreCollection, StorageFilePurposeAndUserQueryInput, StoredFileReader, UploadedFileTypeDeterminer, UploadedFileTypeDeterminerResult, UploadedFileTypeIdentifier } from '@dereekb/firebase';
+import { ArrayOrValue, AsyncDecisionFunction, Maybe } from '@dereekb/util';
+import { StorageFileInitializeFromUploadService } from './storagefile.upload.service';
+export interface StorageFileInitializeFromUploadServiceInitializerInput {
+    /**
+     * The result of the determiner.
+     */
+    readonly determinerResult: UploadedFileTypeDeterminerResult;
+    /**
+     * The uploaded file.
+     */
+    readonly fileDetailsAccessor: StoredFileReader;
+}
+export type StorageFileInitializeFromUploadServiceInitializerResult = StorageFileInitializeFromUploadServiceInitializerStorageFileErrorResult | StorageFileInitializeFromUploadServiceInitializerCreateStorageFileResult | StorageFileInitializeFromUploadServiceInitializerStorageFileDocumentResult;
+export interface StorageFileInitializeFromUploadServiceInitializerStorageFileErrorResult {
+    /**
+     * The error thrown initializing.
+     */
+    readonly error: unknown;
+    /**
+     * If true, the initializer failed permanently and the file should be deleted.
+     */
+    readonly permanentFailure?: boolean;
+}
+export interface StorageFileInitializeFromUploadServiceInitializerCreateStorageFileResult {
+    /**
+     * The result of the createStorageFileDocumentPair function, if a StorageFileDocument was created.
+     */
+    readonly createStorageFileResult: CreateStorageFileDocumentPairResult;
+    /**
+     * If set, the initializer will query existing StorageFiles for the user and purpose and flag them for deletion.
+     *
+     * If true, createStorageFileResult will be used.
+     */
+    readonly flagPreviousForDelete?: Maybe<boolean | StorageFilePurposeAndUserQueryInput>;
+}
+export interface StorageFileInitializeFromUploadServiceInitializerStorageFileDocumentResult {
+    /**
+     * The StorageFileDocument, if it was initialized.
+     */
+    readonly storageFileDocument: StorageFileDocument;
+    /**
+     * If set, the initializer will query existing StorageFiles for the user and purpose and flag them for deletion.
+     *
+     * If true, createStorageFileResult will be used.
+     */
+    readonly flagPreviousForDelete?: Maybe<StorageFilePurposeAndUserQueryInput>;
+}
+export declare function storageFileInitializeFromUploadServiceInitializerResultPermanentFailure(error: unknown): StorageFileInitializeFromUploadServiceInitializerResult;
+/**
+ * Processes the input details accessor and returns the results.
+ */
+export type StorageFileInitializeFromUploadServiceInitializerFunction = (input: StorageFileInitializeFromUploadServiceInitializerInput) => Promise<StorageFileInitializeFromUploadServiceInitializerResult>;
+export interface StorageFileInitializeFromUploadServiceInitializer {
+    /**
+     * The file type(s) identifier that this processor handles.
+     */
+    readonly type: ArrayOrValue<UploadedFileTypeIdentifier>;
+    /**
+     * A determiner that is paired with the processor.
+     *
+     * Determiners defined here are modified to ONLY respond to the types specified in the `type` property. This means that
+     * if the determiner returns a separate type, that result will be altered to be null, instead of returned as a match.
+     */
+    readonly determiner?: Maybe<UploadedFileTypeDeterminer>;
+    /**
+     * Handles the initialization of the StorageFileDocument from the uploaded file.
+     */
+    readonly initialize: StorageFileInitializeFromUploadServiceInitializerFunction;
+}
+export interface StorageFileInitializeFromUploadServiceConfig {
+    /**
+     * If true, will validate that all processor file types have at least one corresponding determiner.
+     */
+    readonly validate?: boolean;
+    /**
+     * The UploadedFileTypeDeterminer(s) to use for determining the upload type of each uploaded file.
+     *
+     * They will be combined together with determiners from the processors.
+     */
+    readonly determiner?: Maybe<ArrayOrValue<UploadedFileTypeDeterminer>>;
+    /**
+     * StorageFilleFirestoreCollection used for retrieving existing StorageFiles for marking them as deleted.
+     */
+    readonly storageFileCollection: StorageFileFirestoreCollection;
+    /**
+     * Configuration for combining the determiners.
+     *
+     * Defaults to:
+     * - completeSearchOnFirstMatch: true
+     */
+    readonly combineDeterminersConfig?: Maybe<CombineUploadFileTypeDeterminerConfig>;
+    /**
+     * Optional function to check if the file is allowed to be initialized.
+     */
+    readonly checkFileIsAllowedToBeInitialized?: Maybe<AsyncDecisionFunction<FirebaseStorageAccessorFile>>;
+    /**
+     * List of handlers for NotificationTaskTypes.
+     */
+    readonly initializer: StorageFileInitializeFromUploadServiceInitializer[];
+}
+/**
+ * A basic StorageFileInitializeFromUploadService implementation.
+ */
+export declare function storageFileInitializeFromUploadService(config: StorageFileInitializeFromUploadServiceConfig): StorageFileInitializeFromUploadService;

package/model/src/lib/storagefile/storagefile.upload.service.initializer.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageFileInitializeFromUploadServiceInitializerResultPermanentFailure = storageFileInitializeFromUploadServiceInitializerResultPermanentFailure;
+exports.storageFileInitializeFromUploadService = storageFileInitializeFromUploadService;
+const firebase_1 = require("@dereekb/firebase");
+const util_1 = require("@dereekb/util");
+const storagefile_util_1 = require("./storagefile.util");
+function storageFileInitializeFromUploadServiceInitializerResultPermanentFailure(error) {
+    return {
+        error,
+        permanentFailure: true
+    };
+}
+/**
+ * A basic StorageFileInitializeFromUploadService implementation.
+ */
+function storageFileInitializeFromUploadService(config) {
+    const { storageFileCollection, initializer: inputInitializers, determiner: inputDeterminers, validate, checkFileIsAllowedToBeInitialized: inputCheckFileIsAllowedToBeInitialized } = config;
+    const allDeterminers = [];
+    const initializers = {};
+    const detailsAccessorFactory = (0, firebase_1.storedFileReaderFactory)();
+    if (inputDeterminers) {
+        (0, util_1.pushItemOrArrayItemsIntoArray)(allDeterminers, inputDeterminers);
+    }
+    // iterate initializers
+    inputInitializers.forEach((initializer) => {
+        const { type: inputTypes, determiner: inputDeterminer } = initializer;
+        const types = (0, util_1.asArray)(inputTypes);
+        types.forEach((type) => {
+            initializers[type] = initializer;
+        });
+        if (inputDeterminer) {
+            const wrappedDeterminer = (0, firebase_1.limitUploadFileTypeDeterminer)(inputDeterminer, types);
+            allDeterminers.push(wrappedDeterminer);
+        }
+    });
+    const determiner = (0, firebase_1.combineUploadFileTypeDeterminers)({
+        determiners: allDeterminers,
+        ...{
+            completeSearchOnFirstMatch: true,
+            ...config.combineDeterminersConfig
+        }
+    });
+    // validate initializers
+    if (validate) {
+        const allInitializerTypes = Object.keys(initializers);
+        const allDeterminerTypes = new Set(determiner.getPossibleFileTypes());
+        // all initializer types should have a corresponding determiner
+        allInitializerTypes.forEach((type) => {
+            if (!allDeterminerTypes.has(type)) {
+                throw new Error(`Initializer type ${type} does not have a corresponding determiner.`);
+            }
+        });
+    }
+    async function determineUploadFileType(input) {
+        const { file } = input;
+        const fileDetailsAccessor = detailsAccessorFactory(file);
+        return determiner.determine(fileDetailsAccessor);
+    }
+    return {
+        checkFileIsAllowedToBeInitialized: inputCheckFileIsAllowedToBeInitialized ?? (0, util_1.asDecisionFunction)(true),
+        determineUploadFileType,
+        initializeFromUpload: async (input) => {
+            const determinerResult = await determineUploadFileType(input);
+            let resultType;
+            let storageFileDocument;
+            let processorError;
+            let previousStorageFilesFlaggedForDeletion;
+            if (determinerResult) {
+                const { input: fileDetailsAccessor } = determinerResult;
+                resultType = 'success';
+                const initializer = initializers[determinerResult.type];
+                if (initializer) {
+                    try {
+                        const initializerResult = await initializer.initialize({ determinerResult, fileDetailsAccessor });
+                        if (initializerResult.error) {
+                            processorError = initializerResult.error;
+                            if (initializerResult.permanentFailure) {
+                                resultType = 'permanent_initializer_failure';
+                            }
+                            else {
+                                resultType = 'initializer_error';
+                            }
+                        }
+                        else {
+                            let flagPreviousForDelete;
+                            if (initializerResult.createStorageFileResult) {
+                                const { createStorageFileResult, flagPreviousForDelete: flagPreviousForDeleteResult } = initializerResult;
+                                storageFileDocument = createStorageFileResult.storageFileDocument;
+                                if (flagPreviousForDeleteResult) {
+                                    if (typeof flagPreviousForDeleteResult === 'object') {
+                                        flagPreviousForDelete = flagPreviousForDeleteResult;
+                                    }
+                                    else {
+                                        const { p, u } = createStorageFileResult.storageFile;
+                                        if (!p || !u) {
+                                            throw new Error('initializeFromUpload(): flagPreviousForDelete=true requires that the created StorageFile have a purpose (p) and user (u).');
+                                        }
+                                        flagPreviousForDelete = {
+                                            purpose: p,
+                                            user: u
+                                        };
+                                    }
+                                }
+                            }
+                            else {
+                                storageFileDocument = initializerResult.storageFileDocument;
+                                flagPreviousForDelete = initializerResult.flagPreviousForDelete;
+                            }
+                            // if flagPreviousForDelete is set, flag the previous storage files for deletion
+                            if (flagPreviousForDelete) {
+                                const flagForDeleteResult = await (0, storagefile_util_1.queryAndFlagStorageFilesForDelete)({
+                                    storageFileCollection,
+                                    constraints: (0, firebase_1.storageFilePurposeAndUserQuery)(flagPreviousForDelete),
+                                    skipDeleteForKeys: [storageFileDocument.key]
+                                });
+                                previousStorageFilesFlaggedForDeletion = flagForDeleteResult.queuedForDeleteCount;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        resultType = 'initializer_error';
+                        processorError = e;
+                    }
+                }
+                else {
+                    resultType = 'no_initializer_configured';
+                }
+            }
+            else {
+                resultType = 'no_determiner_match';
+            }
+            const result = {
+                resultType,
+                storageFileDocument,
+                initializationError: processorError,
+                previousStorageFilesFlaggedForDeletion
+            };
+            return result;
+        }
+    };
+}
+//# sourceMappingURL=storagefile.upload.service.initializer.js.map

package/model/src/lib/storagefile/storagefile.upload.service.initializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storagefile.upload.service.initializer.js","sourceRoot":"","sources":["../../../../../../../packages/firebase-server/model/src/lib/storagefile/storagefile.upload.service.initializer.ts"],"names":[],"mappings":"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"}

package/model/src/lib/storagefile/storagefile.upload.service.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageFileInitializeFromUploadService = void 0;
+/**
+ * Service dedicated to initializing a StorageFileDocument value from an uploaded file.
+ */
+class StorageFileInitializeFromUploadService {
+}
+exports.StorageFileInitializeFromUploadService = StorageFileInitializeFromUploadService;
+//# sourceMappingURL=storagefile.upload.service.js.map

package/model/src/lib/storagefile/storagefile.upload.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storagefile.upload.service.js","sourceRoot":"","sources":["../../../../../../../packages/firebase-server/model/src/lib/storagefile/storagefile.upload.service.ts"],"names":[],"mappings":";;;AAwCA;;GAEG;AACH,MAAsB,sCAAsC;CAiB3D;AAjBD,wFAiBC"}

package/model/src/lib/storagefile/storagefile.util.d.ts

@@ -0,0 +1,37 @@
+import { FirestoreQueryConstraint, StorageFile, StorageFileFirestoreCollection, StorageFileKey } from '@dereekb/firebase';
+import { Maybe, Milliseconds, ArrayOrValue } from '@dereekb/util';
+/**
+ * Describes when a StorageFile should be queued for deletion.
+ *
+ * If true, the StorageFile will be queued for deletion immediately.
+ * If a number, the StorageFile will be queued for deletion after the specified number of milliseconds.
+ * If a Date, the StorageFile will be queued for deletion at the specified date.
+ */
+export type StorageFileQueueForDeleteTime = true | Milliseconds | Date;
+export interface QueryAndFlagStorageFilesForDeleteInput {
+    readonly storageFileCollection: StorageFileFirestoreCollection;
+    readonly constraints: FirestoreQueryConstraint[];
+    readonly queuedForDeleteTime?: Maybe<StorageFileQueueForDeleteTime>;
+    /**
+     * Array of document keys that should be ignored/skipped while flagging.
+     */
+    readonly skipDeleteForKeys?: ArrayOrValue<StorageFileKey>;
+}
+export interface QueryAndFlagStorageFilesForDeleteResult {
+    readonly visitedCount: number;
+    readonly queuedForDeleteCount: number;
+}
+/**
+ * Performs a query and flags the matching StorageFiles for deletion.
+ *
+ * @param input The input for the query and flagging.
+ * @returns The result of the query and flagging.
+ */
+export declare function queryAndFlagStorageFilesForDelete(input: QueryAndFlagStorageFilesForDeleteInput): Promise<QueryAndFlagStorageFilesForDeleteResult>;
+/**
+ * Creates a template for updating a StorageFile to be queued for deletion at the input time.
+ *
+ * @param queueForDeleteTime When to delete the StorageFile. If true or unset, the StorageFile will be flagged to be deleted immediately.
+ * @returns The update template for the StorageFile.
+ */
+export declare function markStorageFileForDeleteTemplate(queueForDeleteTime?: Maybe<StorageFileQueueForDeleteTime>): Pick<StorageFile, 'sdat' | 'fs'>;

package/model/src/lib/storagefile/storagefile.util.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryAndFlagStorageFilesForDelete = queryAndFlagStorageFilesForDelete;
+exports.markStorageFileForDeleteTemplate = markStorageFileForDeleteTemplate;
+const firebase_1 = require("@dereekb/firebase");
+const util_1 = require("@dereekb/util");
+/**
+ * Performs a query and flags the matching StorageFiles for deletion.
+ *
+ * @param input The input for the query and flagging.
+ * @returns The result of the query and flagging.
+ */
+async function queryAndFlagStorageFilesForDelete(input) {
+    const { storageFileCollection, constraints, queuedForDeleteTime: inputQueueForDeleteTime, skipDeleteForKeys } = input;
+    const queuedForDeleteTime = inputQueueForDeleteTime ?? true;
+    const skipDeleteSet = new Set((0, util_1.asArray)(skipDeleteForKeys));
+    let visitedCount = 0;
+    let queuedForDeleteCount = 0;
+    await (0, firebase_1.iterateFirestoreDocumentSnapshotPairs)({
+        documentAccessor: storageFileCollection.documentAccessor(),
+        iterateSnapshotPair: async (snapshotPair) => {
+            const { document, data: storageFile } = snapshotPair;
+            if (!storageFile.sdat && !skipDeleteSet.has(storageFile.key)) {
+                await document.update(markStorageFileForDeleteTemplate(queuedForDeleteTime));
+                queuedForDeleteCount++;
+            }
+            visitedCount++;
+        },
+        queryFactory: storageFileCollection,
+        constraintsFactory: () => constraints,
+        batchSize: undefined,
+        performTasksConfig: {
+            maxParallelTasks: 20
+        }
+    });
+    return {
+        visitedCount,
+        queuedForDeleteCount
+    };
+}
+/**
+ * Creates a template for updating a StorageFile to be queued for deletion at the input time.
+ *
+ * @param queueForDeleteTime When to delete the StorageFile. If true or unset, the StorageFile will be flagged to be deleted immediately.
+ * @returns The update template for the StorageFile.
+ */
+function markStorageFileForDeleteTemplate(queueForDeleteTime) {
+    const updateTemplate = {
+        sdat: queueForDeleteTime === true || queueForDeleteTime == null ? new Date() : (0, util_1.dateFromDateOrTimeNumber)(queueForDeleteTime),
+        fs: firebase_1.StorageFileState.QUEUED_FOR_DELETE
+    };
+    return updateTemplate;
+}
+//# sourceMappingURL=storagefile.util.js.map

package/model/src/lib/storagefile/storagefile.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storagefile.util.js","sourceRoot":"","sources":["../../../../../../../packages/firebase-server/model/src/lib/storagefile/storagefile.util.ts"],"names":[],"mappings":";;AAiCA,8EAgCC;AAQD,4EAOC;AAhFD,gDAAmL;AACnL,wCAAqG;AA0BrG;;;;;GAKG;AACI,KAAK,UAAU,iCAAiC,CAAC,KAA6C;IACnG,MAAM,EAAE,qBAAqB,EAAE,WAAW,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC;IACtH,MAAM,mBAAmB,GAAG,uBAAuB,IAAI,IAAI,CAAC;IAC5D,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,IAAA,cAAO,EAAC,iBAAiB,CAAC,CAAC,CAAC;IAE1D,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,oBAAoB,GAAG,CAAC,CAAC;IAE7B,MAAM,IAAA,gDAAqC,EAAC;QAC1C,gBAAgB,EAAE,qBAAqB,CAAC,gBAAgB,EAAE;QAC1D,mBAAmB,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE;YAC1C,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,YAAY,CAAC;YAErD,IAAI,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC7D,MAAM,QAAQ,CAAC,MAAM,CAAC,gCAAgC,CAAC,mBAAmB,CAAC,CAAC,CAAC;gBAC7E,oBAAoB,EAAE,CAAC;YACzB,CAAC;YAED,YAAY,EAAE,CAAC;QACjB,CAAC;QACD,YAAY,EAAE,qBAAqB;QACnC,kBAAkB,EAAE,GAAG,EAAE,CAAC,WAAW;QACrC,SAAS,EAAE,SAAS;QACpB,kBAAkB,EAAE;YAClB,gBAAgB,EAAE,EAAE;SACrB;KACF,CAAC,CAAC;IAEH,OAAO;QACL,YAAY;QACZ,oBAAoB;KACrB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,gCAAgC,CAAC,kBAAyD;IACxG,MAAM,cAAc,GAAqC;QACvD,IAAI,EAAE,kBAAkB,KAAK,IAAI,IAAI,kBAAkB,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAA,+BAAwB,EAAC,kBAAkB,CAAC;QAC3H,EAAE,EAAE,2BAAgB,CAAC,iBAAiB;KACvC,CAAC;IAEF,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/firebase-server",
-  "version": "12.4.4",
+  "version": "12.5.0",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",

package/src/lib/storage/driver.accessor.d.ts

@@ -1,9 +1,9 @@
 import { type FirebaseStorageAccessorDriver, type FirebaseStorageAccessorFile, type FirebaseStorageAccessorFolder, type StoragePath, type StorageMetadata, type StorageBucketId } from '@dereekb/firebase';
 import { type SlashPathFolder } from '@dereekb/util';
-import { type GetFilesOptions, type Storage as GoogleCloudStorage, type File as GoogleCloudFile, type FileMetadata } from '@google-cloud/storage';
-export declare function googleCloudStorageBucketForStorageFilePath(storage: GoogleCloudStorage, path: StoragePath): import("@google-cloud/storage").Bucket;
+import { type GetFilesOptions, type Storage as GoogleCloudStorage, type File as GoogleCloudFile, type FileMetadata, Bucket } from '@google-cloud/storage';
+export declare function googleCloudStorageBucketForStorageFilePath(storage: GoogleCloudStorage, path: StoragePath): Bucket;
 export declare function googleCloudStorageFileForStorageFilePath(storage: GoogleCloudStorage, path: StoragePath): GoogleCloudFile;
-export type GoogleCloudStorageAccessorFile = FirebaseStorageAccessorFile<GoogleCloudFile>;
+export type GoogleCloudStorageAccessorFile = FirebaseStorageAccessorFile<GoogleCloudFile> & Required<Pick<FirebaseStorageAccessorFile<GoogleCloudFile>, 'uploadStream' | 'getStream'>>;
 export declare function googleCloudFileMetadataToStorageMetadata(file: GoogleCloudFile, metadata: FileMetadata): StorageMetadata;
 export declare function googleCloudStorageAccessorFile(storage: GoogleCloudStorage, storagePath: StoragePath): GoogleCloudStorageAccessorFile;
 export type GoogleCloudStorageAccessorFolder = FirebaseStorageAccessorFolder<GoogleCloudFile>;

package/src/lib/storage/driver.accessor.js

@@ -9,6 +9,8 @@ exports.googleCloudStorageAccessorFolder = googleCloudStorageAccessorFolder;
 exports.googleCloudStorageFirebaseStorageAccessorDriver = googleCloudStorageFirebaseStorageAccessorDriver;
 const firebase_1 = require("@dereekb/firebase");
 const util_1 = require("@dereekb/util");
+const storage_1 = require("@google-cloud/storage");
+const date_fns_1 = require("date-fns");
 const types_1 = require("util/types");
 function googleCloudStorageBucketForStorageFilePath(storage, path) {
     return storage.bucket(path.bucketId);
@@ -21,6 +23,7 @@ function googleCloudFileMetadataToStorageMetadata(file, metadata) {
     const generation = String(metadata.generation ?? file.generation);
     const metageneration = String(metadata.metageneration);
     const size = Number(metadata.size);
+    const customMetadata = metadata.metadata;
     return {
         bucket: file.bucket.name,
         fullPath,
@@ -36,7 +39,7 @@ function googleCloudFileMetadataToStorageMetadata(file, metadata) {
         contentEncoding: metadata.contentEncoding,
         contentLanguage: metadata.contentLanguage,
         contentType: metadata.contentType,
-        customMetadata: metadata.customMetadata
+        customMetadata
     };
 }
 function googleCloudStorageAccessorFile(storage, storagePath) {
@@ -51,26 +54,84 @@ function googleCloudStorageAccessorFile(storage, storagePath) {
                 : undefined)
         };
     }
+    function _configureMetadata(options) {
+        const customMetadata = (0, util_1.filterUndefinedValues)({
+            ...options.metadata?.customMetadata,
+            ...options?.customMetadata
+        });
+        return (0, util_1.filterUndefinedValues)({
+            cacheControl: options.metadata?.cacheControl,
+            contentDisposition: options.metadata?.contentDisposition,
+            contentEncoding: options.metadata?.contentEncoding,
+            contentLanguage: options.metadata?.contentLanguage,
+            contentType: options.metadata?.contentType,
+            metadata: !(0, util_1.objectHasNoKeys)(customMetadata) ? customMetadata : undefined
+        });
+    }
     function makeUploadOptions(options) {
         let metadata;
-        if (options?.contentType) {
-            metadata = {
-                contentType: options?.contentType
-            };
+        if (options != null) {
+            metadata = _configureMetadata({
+                metadata: {
+                    ...options.metadata,
+                    contentType: options.contentType ?? options.metadata?.contentType
+                },
+                customMetadata: options.customMetadata
+            });
         }
         return {
             // non-resumable
             resumable: false,
-            // add content type
+            // add content type and other custom metadata
             ...(metadata ? { metadata } : undefined)
         };
     }
-    return {
+    function asFileMetadata(metadata) {
+        return _configureMetadata({ metadata });
+    }
+    function makeStoragePathForPath(newPath) {
+        let path;
+        if (typeof newPath === 'string') {
+            path = {
+                bucketId: file.bucket.name,
+                pathString: newPath
+            };
+        }
+        else {
+            path = newPath;
+        }
+        return path;
+    }
+    async function copy(newPath, options) {
+        const newStoragePath = makeStoragePathForPath(newPath);
+        const newFile = googleCloudStorageAccessorFile(storage, newStoragePath);
+        return _copyWithFile(newFile, options);
+    }
+    async function _copyWithFile(newFile, options) {
+        const copyOptions = {
+            ...options
+        };
+        await file.copy(newFile.reference, copyOptions);
+        return newFile;
+    }
+    const accessorFile = {
         reference: file,
         storagePath,
         exists: async () => file.exists().then((x) => x[0]),
         getDownloadUrl: async () => file.getMetadata().then((x) => file.publicUrl()),
+        getSignedUrl: async (input) => {
+            const expires = input?.expiresAt ?? (input?.expiresIn != null ? (0, date_fns_1.addMilliseconds)(new Date(), input.expiresIn) : (0, date_fns_1.addHours)(new Date(), 1));
+            const config = {
+                ...input,
+                action: input?.action ?? 'read',
+                expiresIn: undefined,
+                expiresAt: undefined,
+                expires
+            };
+            return file.getSignedUrl(config).then((x) => x[0]);
+        },
         getMetadata: () => file.getMetadata().then((x) => googleCloudFileMetadataToStorageMetadata(file, x[0])),
+        setMetadata: (metadata) => file.setMetadata(asFileMetadata(metadata)).then((x) => googleCloudFileMetadataToStorageMetadata(file, x[0])),
         getBytes: (maxDownloadSizeBytes) => file.download(makeDownloadOptions(maxDownloadSizeBytes)).then((x) => x[0]),
         getStream: (maxDownloadSizeBytes) => file.createReadStream(makeDownloadOptions(maxDownloadSizeBytes)),
         upload: async (input, options) => {
@@ -105,8 +166,30 @@ function googleCloudStorageAccessorFile(storage, storagePath) {
             return file.save(data, makeUploadOptions(options));
         },
         uploadStream: (options) => file.createWriteStream(makeUploadOptions(options)),
+        move: async (newPath, options) => {
+            const newStoragePath = makeStoragePathForPath(newPath);
+            const newFile = googleCloudStorageAccessorFile(storage, newStoragePath);
+            const moveOptions = {
+                ...options
+            };
+            await file.moveFileAtomic(newFile.reference, moveOptions).catch(async (e) => {
+                if (e instanceof storage_1.ApiError && e.response?.statusMessage === 'Not Implemented') {
+                    // NOTE: This is not implemented in storage emulator, so it will fail with this error in testing.
+                    // https://github.com/firebase/firebase-tools/issues/3751
+                    // we can perform the same task using copy and then deleting this file.
+                    await copy(newPath, moveOptions);
+                    await accessorFile.delete();
+                }
+                else {
+                    throw e;
+                }
+            });
+            return newFile;
+        },
+        copy,
         delete: (options) => file.delete(options).then((x) => undefined)
     };
+    return accessorFile;
 }
 exports.googleCloudStorageListFilesResultFactory = (0, firebase_1.storageListFilesResultFactory)({
     hasItems(result) {
@@ -115,8 +198,11 @@ exports.googleCloudStorageListFilesResultFactory = (0, firebase_1.storageListFil
     hasNext: (result) => {
         return result.nextQuery != null;
     },
-    next(storage, folder, result) {
-        return folder.list(result.nextQuery);
+    nextPageTokenFromResult(result) {
+        return result.nextQuery?.pageToken;
+    },
+    next(storage, options, folder, result) {
+        return folder.list({ ...options, ...result.nextQuery });
     },
     file(storage, fileResult) {
         return googleCloudStorageAccessorFile(storage, fileResult.storagePath);
@@ -141,17 +227,23 @@ function googleCloudStorageAccessorFolder(storage, storagePath) {
         storagePath,
         exists: async () => folder.list({ maxResults: 1 }).then((x) => x.hasItems()),
         list: (options) => {
-            return bucket
-                .getFiles({
-                ...options,
-                delimiter: util_1.SLASH_PATH_SEPARATOR,
+            const { maxResults, pageToken, includeNestedResults: listAll } = options ?? {};
+            const listOptions = {
+                maxResults,
+                pageToken,
                 autoPaginate: false,
                 versions: false,
-                maxResults: options?.maxResults,
-                // includeTrailingDelimiter: true,
-                prefix: (0, util_1.toRelativeSlashPathStartType)((0, util_1.fixMultiSlashesInSlashPath)(storagePath.pathString + '/')) // make sure the folder always ends with a slash
-            })
-                .then((x) => {
+                ...(listAll
+                    ? {
+                        prefix: (0, util_1.toRelativeSlashPathStartType)((0, util_1.fixMultiSlashesInSlashPath)(storagePath.pathString + '/'))
+                    }
+                    : {
+                        // includeTrailingDelimiter: true,
+                        delimiter: util_1.SLASH_PATH_SEPARATOR,
+                        prefix: (0, util_1.toRelativeSlashPathStartType)((0, util_1.fixMultiSlashesInSlashPath)(storagePath.pathString + '/')) // make sure the folder always ends with a slash
+                    })
+            };
+            return bucket.getFiles(listOptions).then((x) => {
                 const files = x[0];
                 const nextQuery = x[1];
                 const apiResponse = x[2];
@@ -168,6 +260,7 @@ function googleCloudStorageAccessorFolder(storage, storagePath) {
 }
 function googleCloudStorageFirebaseStorageAccessorDriver() {
     return {
+        type: 'server',
         file: (storage, path) => googleCloudStorageAccessorFile(storage, path),
         folder: (storage, path) => googleCloudStorageAccessorFolder(storage, path)
     };