@concord-consortium/object-storage 1.0.0-pre.4 → 1.0.0-pre.6

package/dist/demo-object-storage.d.ts

@@ -1,39 +1,20 @@
-import { DemoObjectStorageConfig, IObjectStorage, ObjectMetadata, ObjectData, StoredObject, ObjectWithId, MonitorCallback, DemonitorFunction, AddOptions } from './types';
+import { DemoObjectStorageConfig, IObjectStorage, ObjectMetadata, ObjectData, StoredObject, MonitorCallback, DemonitorFunction, AddOptions, ObjectMetadataWithId } from './types';
 export declare class DemoObjectStorage implements IObjectStorage {
     private config;
     private objects;
     private monitors;
     constructor(config: DemoObjectStorageConfig);
-    /**
-     * Lists metadata documents for objects owned by the current user
-     */
-    listMine(): Promise<ObjectWithId[]>;
-    /**
-     * Lists metadata documents for objects linked to the current user
-     */
-    listLinked(): Promise<ObjectWithId[]>;
+    private getQuestionMetadata;
     /**
      * Lists metadata documents for objects associated with specific question IDs
      */
-    list(questionIds: string[]): Promise<ObjectWithId[]>;
-    /**
-     * Monitors metadata documents for objects owned by the current user
-     * Invokes callback at start and on any change
-     * Returns a function to stop monitoring
-     */
-    monitorMine(callback: MonitorCallback): DemonitorFunction;
-    /**
-     * Monitors metadata documents for objects linked to the current user
-     * Invokes callback at start and on any change
-     * Returns a function to stop monitoring
-     */
-    monitorLinked(callback: MonitorCallback): DemonitorFunction;
+    list(questionId: string): Promise<ObjectMetadataWithId[]>;
     /**
      * Monitors metadata documents for objects associated with specific question IDs
      * Invokes callback at start and on any change
      * Returns a function to stop monitoring
      */
-    monitor(questionIds: string[], callback: MonitorCallback): DemonitorFunction;
+    monitor(questionId: string, callback: MonitorCallback): DemonitorFunction;
     /**
      * Adds both metadata and data documents for a new object
      * Returns the generated object ID (nanoid) or the provided ID if specified in options

package/dist/demo-object-storage.js

@@ -11,76 +11,33 @@ class DemoObjectStorage {
         this.objects = new Map();
         this.monitors = new Map();
     }
-    /**
-     * Lists metadata documents for objects owned by the current user
-     */
-    async listMine() {
-        return Array.from(this.objects.values());
-    }
-    /**
-     * Lists metadata documents for objects linked to the current user
-     */
-    async listLinked() {
-        // not applicable in demo storage
-        return [];
+    getQuestionMetadata() {
+        // In demo mode, just return all objects since there are no other questions
+        // that can use this storage instance
+        return Array.from(this.objects.entries()).map(([id, obj]) => {
+            return { id, metadata: obj.metadata };
+        });
     }
     /**
      * Lists metadata documents for objects associated with specific question IDs
      */
-    async list(questionIds) {
-        // In demo mode, just return all objects
-        return Array.from(this.objects.values());
-    }
-    /**
-     * Monitors metadata documents for objects owned by the current user
-     * Invokes callback at start and on any change
-     * Returns a function to stop monitoring
-     */
-    monitorMine(callback) {
-        const key = 'mine';
-        if (!this.monitors.has(key)) {
-            this.monitors.set(key, []);
-        }
-        this.monitors.get(key).push(callback);
-        // Invoke callback immediately with current state
-        callback(Array.from(this.objects.values()));
-        return () => {
-            const callbacks = this.monitors.get(key);
-            if (callbacks) {
-                const index = callbacks.indexOf(callback);
-                if (index > -1) {
-                    callbacks.splice(index, 1);
-                }
-            }
-        };
-    }
-    /**
-     * Monitors metadata documents for objects linked to the current user
-     * Invokes callback at start and on any change
-     * Returns a function to stop monitoring
-     */
-    monitorLinked(callback) {
-        // not applicable in demo storage
-        callback([]);
-        return () => {
-            // no-op
-        };
+    async list(questionId) {
+        return this.getQuestionMetadata();
     }
     /**
      * Monitors metadata documents for objects associated with specific question IDs
      * Invokes callback at start and on any change
      * Returns a function to stop monitoring
      */
-    monitor(questionIds, callback) {
-        const key = `monitor-${questionIds.join(',')}`;
-        if (!this.monitors.has(key)) {
-            this.monitors.set(key, []);
+    monitor(questionId, callback) {
+        if (!this.monitors.has(questionId)) {
+            this.monitors.set(questionId, []);
         }
-        this.monitors.get(key).push(callback);
+        this.monitors.get(questionId).push(callback);
         // Invoke callback immediately with current state
-        callback(Array.from(this.objects.values()));
+        callback(this.getQuestionMetadata());
         return () => {
-            const callbacks = this.monitors.get(key);
+            const callbacks = this.monitors.get(questionId);
             if (callbacks) {
                 const index = callbacks.indexOf(callback);
                 if (index > -1) {
@@ -95,12 +52,7 @@ class DemoObjectStorage {
      */
     async add(object, options) {
         const id = options?.id ?? (0, nanoid_1.nanoid)();
-        const objectWithId = {
-            id,
-            metadata: object.metadata,
-            data: object.data
-        };
-        this.objects.set(id, objectWithId);
+        this.objects.set(id, object);
         // Notify all monitors
         this.notifyMonitors();
         return id;
@@ -151,7 +103,7 @@ class DemoObjectStorage {
      * Notifies all active monitors of changes
      */
     notifyMonitors() {
-        const allObjects = Array.from(this.objects.values());
+        const allObjects = this.getQuestionMetadata();
         this.monitors.forEach(callbacks => {
             callbacks.forEach(callback => callback(allObjects));
         });

package/dist/firebase-object-storage.d.ts

@@ -1,37 +1,37 @@
-import { FirebaseObjectStorageConfig, IObjectStorage, ObjectMetadata, ObjectData, StoredObject, ObjectWithId, MonitorCallback, DemonitorFunction, AddOptions } from './types';
+import "firebase/compat/auth";
+import "firebase/compat/firestore";
+import { FirebaseObjectStorageConfig, IObjectStorage, ObjectMetadata, ObjectData, StoredObject, MonitorCallback, DemonitorFunction, AddOptions, ObjectMetadataWithId } from './types';
 export declare class FirebaseObjectStorage implements IObjectStorage {
     private config;
+    private initPromise;
+    private initialized;
+    private app;
     constructor(config: FirebaseObjectStorageConfig);
-    /**
-     * Lists metadata documents for objects owned by the current user
-     */
-    listMine(): Promise<ObjectWithId[]>;
-    /**
-     * Lists metadata documents for objects linked to the current user
-     */
-    listLinked(): Promise<ObjectWithId[]>;
+    private initialize;
+    private ensureInitialized;
+    private createDocument;
+    private getPaths;
+    private getRefs;
+    private getMetadataQuery;
+    /**
+     * Ensures the provided ID is in question ID format as opposed to reference ID format
+     *
+     * eg: "404-MWInteractive" transforms to "mw_interactive_404"
+     *
+     * @param questionOrRefId
+     * @returns
+     */
+    private ensureIdIsQuestionId;
     /**
      * Lists metadata documents for objects associated with specific question IDs
      */
-    list(questionIds: string[]): Promise<ObjectWithId[]>;
-    /**
-     * Monitors metadata documents for objects owned by the current user
-     * Invokes callback at start and on any change
-     * Returns a function to stop monitoring
-     */
-    monitorMine(callback: MonitorCallback): DemonitorFunction;
-    /**
-     * Monitors metadata documents for objects linked to the current user
-     * Invokes callback at start and on any change
-     * Returns a function to stop monitoring
-     */
-    monitorLinked(callback: MonitorCallback): DemonitorFunction;
+    list(questionOrRefId: string): Promise<ObjectMetadataWithId[]>;
     /**
      * Monitors metadata documents for objects associated with specific question IDs
      * Invokes callback at start and on any change
      * Returns a function to stop monitoring
      */
-    monitor(questionIds: string[], callback: MonitorCallback): DemonitorFunction;
+    monitor(questionOrRefId: string, callback: MonitorCallback): DemonitorFunction;
     /**
      * Adds both metadata and data documents for a new object
      * Returns the generated object ID (nanoid) or the provided ID if specified in options

package/dist/firebase-object-storage.js

@@ -1,69 +1,146 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirebaseObjectStorage = void 0;
 const nanoid_1 = require("nanoid");
+const app_1 = __importDefault(require("firebase/compat/app"));
+require("firebase/compat/auth");
+require("firebase/compat/firestore");
 class FirebaseObjectStorage {
     constructor(config) {
+        this.initialized = false;
         if (config.version !== 1) {
             throw new Error(`Unsupported config version: ${config.version}. Expected version 1.`);
         }
-        this.config = config;
+        this.config = { ...config };
+        // ensure the question id is in the correct format
+        this.config.questionId = this.ensureIdIsQuestionId(this.config.questionId);
+        this.app = app_1.default.initializeApp(this.config.app);
+        this.app.firestore().settings({
+            ignoreUndefinedProperties: true,
+        });
+        // Start initialization immediately in constructor
+        this.initPromise = this.initialize();
     }
-    /**
-     * Lists metadata documents for objects owned by the current user
-     */
-    async listMine() {
-        // TODO: Implement Firebase query for user's own objects
-        return [];
+    async initialize() {
+        if (this.initialized)
+            return;
+        if (this.config.user.type === "authenticated") {
+            // ensure any previous auth state is cleared before signing in
+            await this.app.auth().signOut();
+            await this.app.auth().signInWithCustomToken(this.config.user.jwt);
+        }
+        this.initialized = true;
     }
-    /**
-     * Lists metadata documents for objects linked to the current user
-     */
-    async listLinked() {
-        // TODO: Implement Firebase query for linked objects
-        return [];
+    async ensureInitialized() {
+        await this.initPromise;
     }
-    /**
-     * Lists metadata documents for objects associated with specific question IDs
-     */
-    async list(questionIds) {
-        // TODO: Implement Firebase query for objects by question IDs
-        return [];
+    createDocument(contents) {
+        const { questionId } = this.config;
+        if (this.config.user.type === "authenticated") {
+            const { contextId, platformId, platformUserId, resourceLinkId } = this.config.user;
+            return {
+                created_at: app_1.default.firestore.FieldValue.serverTimestamp(),
+                context_id: contextId,
+                platform_id: platformId,
+                platform_user_id: platformUserId,
+                resource_link_id: resourceLinkId,
+                run_key: "",
+                question_id: questionId,
+                ...contents
+            };
+        }
+        else {
+            const { runKey } = this.config.user;
+            return {
+                created_at: app_1.default.firestore.FieldValue.serverTimestamp(),
+                run_key: runKey,
+                platform_user_id: runKey,
+                question_id: questionId,
+                ...contents
+            };
+        }
+    }
+    getPaths(objectId) {
+        const metadataPath = `${this.config.root}/object_store_metadata${objectId ? `/${objectId}` : ''}`;
+        const dataPath = `${this.config.root}/object_store_data${objectId ? `/${objectId}` : ''}`;
+        return { metadataPath, dataPath };
+    }
+    getRefs(objectId) {
+        const { metadataPath, dataPath } = this.getPaths(objectId);
+        const metadataRef = this.app.firestore().doc(metadataPath);
+        const dataRef = this.app.firestore().doc(dataPath);
+        return { metadataRef, dataRef };
+    }
+    getMetadataQuery(questionOrRefId) {
+        const questionId = this.ensureIdIsQuestionId(questionOrRefId);
+        const { metadataPath } = this.getPaths();
+        let query = this.app.firestore().collection(metadataPath)
+            .where("question_id", "==", questionId);
+        if (this.config.user.type === "authenticated") { // logged in user
+            const { contextId, platformId, resourceLinkId, platformUserId } = this.config.user;
+            query = query
+                .where("context_id", "==", contextId)
+                .where("platform_id", "==", platformId)
+                .where("platform_user_id", "==", platformUserId.toString())
+                .where("resource_link_id", "==", resourceLinkId);
+        }
+        else {
+            query = query.where("run_key", "==", this.config.user.runKey);
+        }
+        query = query.orderBy("created_at", "asc");
+        return query;
     }
     /**
-     * Monitors metadata documents for objects owned by the current user
-     * Invokes callback at start and on any change
-     * Returns a function to stop monitoring
+     * Ensures the provided ID is in question ID format as opposed to reference ID format
+     *
+     * eg: "404-MWInteractive" transforms to "mw_interactive_404"
+     *
+     * @param questionOrRefId
+     * @returns
      */
-    monitorMine(callback) {
-        // TODO: Implement Firebase realtime listener for user's own objects
-        callback([]);
-        return () => {
-            // TODO: Implement cleanup
-        };
+    ensureIdIsQuestionId(questionOrRefId) {
+        const refIdRegEx = /(\d*)-(\D*)/g;
+        const parsed = refIdRegEx.exec(questionOrRefId);
+        if (parsed?.length) {
+            const [, embeddableId, embeddableType] = parsed;
+            const snakeCased = embeddableType.replace(/(?!^)([A-Z])/g, "_$1").toLowerCase();
+            return `${snakeCased}_${embeddableId}`;
+        }
+        return questionOrRefId;
     }
     /**
-     * Monitors metadata documents for objects linked to the current user
-     * Invokes callback at start and on any change
-     * Returns a function to stop monitoring
+     * Lists metadata documents for objects associated with specific question IDs
      */
-    monitorLinked(callback) {
-        // TODO: Implement Firebase realtime listener for linked objects
-        callback([]);
-        return () => {
-            // TODO: Implement cleanup
-        };
+    async list(questionOrRefId) {
+        await this.ensureInitialized();
+        const query = this.getMetadataQuery(questionOrRefId);
+        const querySnapshot = await query.get();
+        const results = [];
+        querySnapshot.forEach(doc => {
+            results.push({ id: doc.id, metadata: doc.data().metadata });
+        });
+        return results;
     }
     /**
      * Monitors metadata documents for objects associated with specific question IDs
      * Invokes callback at start and on any change
      * Returns a function to stop monitoring
      */
-    monitor(questionIds, callback) {
-        // TODO: Implement Firebase realtime listener for objects by question IDs
-        callback([]);
+    monitor(questionOrRefId, callback) {
+        // await this.ensureInitialized();
+        const query = this.getMetadataQuery(questionOrRefId);
+        const unsub = query.onSnapshot(snapshot => {
+            const results = [];
+            snapshot.forEach(doc => {
+                results.push({ id: doc.id, metadata: doc.data().metadata });
+            });
+            callback(results);
+        });
         return () => {
-            // TODO: Implement cleanup
+            unsub();
         };
     }
     /**
@@ -71,36 +148,56 @@ class FirebaseObjectStorage {
      * Returns the generated object ID (nanoid) or the provided ID if specified in options
      */
     async add(object, options) {
-        // TODO: Generate nanoid if not provided in options
-        // TODO: Add metadata document to Firebase
-        // TODO: Add data document to Firebase
-        const newObjectId = options?.id ?? 'placeholder-id';
+        await this.ensureInitialized();
+        const newObjectId = options?.id ?? (0, nanoid_1.nanoid)();
+        const { data, metadata } = object;
+        const { metadataRef, dataRef } = this.getRefs(newObjectId);
+        const dataDoc = this.createDocument({ data });
+        const metadataDoc = this.createDocument({ metadata });
+        const batch = this.app.firestore().batch();
+        batch.set(dataRef, dataDoc);
+        batch.set(metadataRef, metadataDoc);
+        await batch.commit();
         return newObjectId;
     }
     /**
      * Reads both metadata and data documents for an object
      */
     async read(objectId) {
-        // TODO: Read metadata document from Firebase
-        // TODO: Read data document from Firebase
-        return {
-            metadata: {},
-            data: {}
-        };
+        await this.ensureInitialized();
+        const metadata = await this.readMetadata(objectId);
+        if (!metadata) {
+            return undefined;
+        }
+        const data = await this.readData(objectId);
+        if (!data) {
+            return undefined;
+        }
+        return { metadata, data };
     }
     /**
      * Reads only the metadata document for an object
      */
     async readMetadata(objectId) {
-        // TODO: Read metadata document from Firebase
-        return {};
+        await this.ensureInitialized();
+        const { metadataRef } = this.getRefs(objectId);
+        const metadataSnapshot = await metadataRef.get();
+        if (!metadataSnapshot.exists) {
+            return undefined;
+        }
+        return metadataSnapshot.data()?.metadata ?? {};
     }
     /**
      * Reads only the data document for an object
      */
     async readData(objectId) {
-        // TODO: Read data document from Firebase
-        return {};
+        await this.ensureInitialized();
+        const { dataRef } = this.getRefs(objectId);
+        const dataSnapshot = await dataRef.get();
+        if (!dataSnapshot.exists) {
+            return undefined;
+        }
+        return dataSnapshot.data()?.data ?? {};
     }
     /**
      * Generates a new unique ID using nanoid

package/dist/index.d.ts

@@ -2,5 +2,5 @@ export { DemoObjectStorage } from './demo-object-storage';
 export { FirebaseObjectStorage } from './firebase-object-storage';
 export { createObjectStorage } from './object-storage';
 export { ObjectStorageProvider, useObjectStorage } from './object-storage-context';
-export { IObjectStorage, ObjectStorageConfig, DemoObjectStorageConfig, FirebaseObjectStorageConfig, ObjectMetadata, ObjectData, StoredObject, ObjectWithId, MonitorCallback, DemonitorFunction } from './types';
+export { IObjectStorage, ObjectStorageConfig, DemoObjectStorageConfig, FirebaseObjectStorageUser, FirebaseObjectStorageConfig, ObjectMetadata, ObjectData, StoredObject, ObjectWithId, MonitorCallback, DemonitorFunction } from './types';
 export * from './typed-object';

package/dist/typed-object.d.ts

@@ -64,7 +64,7 @@ export declare class TypedObject implements StoredObject {
     data: TypedData;
     constructor(options?: TypedObjectOptions);
     static IsSupportedTypedObject(storedObject: StoredObject): boolean;
-    static IsSupportedTypedObjectMetadata(storedObjectMetadata?: StoredObject["metadata"]): boolean;
+    static IsSupportedTypedObjectMetadata(storedObjectMetadata?: StoredObject["metadata"]): storedObjectMetadata is TypedMetadata;
     static FromStoredObject(id: string, storedObject: StoredObject): TypedObject;
     addImage(options: AddImageOptions): void;
     addDataTable(options: AddDataTableOptions): void;

package/dist/typed-object.js

@@ -69,8 +69,13 @@ class TypedObject {
         if (options.description !== undefined) {
             this.metadata.items[id].description = options.description;
         }
+        // firebase does not support nested arrays well, so we store rows as an object with numeric keys
+        const rowsObj = {};
+        options.rows.forEach((row, index) => {
+            rowsObj[index.toString()] = row;
+        });
         this.data[id] = {
-            rows: options.rows
+            rows: rowsObj
         };
     }
     addText(options) {

package/dist/types.d.ts

@@ -1,22 +1,35 @@
 export interface DemoObjectStorageConfig {
-    type: "demo";
     version: 1;
+    type: "demo";
+}
+export interface AuthenticatedUser {
+    type: "authenticated";
+    jwt: string;
+    contextId: string;
+    platformId: string;
+    resourceLinkId: string;
+    platformUserId: string;
+}
+export interface AnonymousUser {
+    type: "anonymous";
+    runKey: string;
 }
+export type FirebaseObjectStorageUser = AuthenticatedUser | AnonymousUser;
 export interface FirebaseObjectStorageConfig {
-    type: "firebase";
     version: 1;
+    type: "firebase";
+    app: Object;
+    root: string;
+    user: FirebaseObjectStorageUser;
+    questionId: string;
 }
 export type ObjectStorageConfig = DemoObjectStorageConfig | FirebaseObjectStorageConfig;
 export interface AddOptions {
     id?: string;
 }
 export interface IObjectStorage {
-    listMine(): Promise<ObjectWithId[]>;
-    listLinked(): Promise<ObjectWithId[]>;
-    list(questionIds: string[]): Promise<ObjectWithId[]>;
-    monitorMine(callback: MonitorCallback): DemonitorFunction;
-    monitorLinked(callback: MonitorCallback): DemonitorFunction;
-    monitor(questionIds: string[], callback: MonitorCallback): DemonitorFunction;
+    list(questionOrRefId: string): Promise<ObjectMetadataWithId[]>;
+    monitor(questionOrRefId: string, callback: MonitorCallback): DemonitorFunction;
     add(object: StoredObject, options?: AddOptions): Promise<string>;
     read(objectId: string): Promise<StoredObject | undefined>;
     readMetadata(objectId: string): Promise<ObjectMetadata | undefined>;
@@ -33,8 +46,18 @@ export interface StoredObject {
     metadata: ObjectMetadata;
     data: ObjectData;
 }
-export interface ObjectWithId extends StoredObject {
+export interface ObjectMetadataWithId {
+    id: string;
+    metadata: ObjectMetadata;
+}
+export interface ObjectDataWithId {
+    id: string;
+    data: ObjectData;
+}
+export interface ObjectWithId {
     id: string;
+    metadata: ObjectMetadata;
+    data: ObjectData;
 }
-export type MonitorCallback = (objects: ObjectWithId[]) => void;
+export type MonitorCallback = (objects: ObjectMetadataWithId[]) => void;
 export type DemonitorFunction = () => void;

package/dist/types.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@concord-consortium/object-storage",
-  "version": "1.0.0-pre.4",
+  "version": "1.0.0-pre.6",
   "description": "A TypeScript library for object storage",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "build:watch": "tsc --watch",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
@@ -25,6 +26,7 @@
     "access": "public"
   },
   "dependencies": {
+    "firebase": "^9.8.1",
     "nanoid": "^3.3.7"
   },
   "peerDependencies": {