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

package/README.md

@@ -39,7 +39,9 @@ function YourComponent() {
 
   // Use storage methods
   const handleAdd = async () => {
-    const id = await storage.add({ metadata: {}, data: {} });
+    const object = new StoredObject();
+    const result = await storage.add(object);
+    console.log('Added object with id:', result.id);
   };
 
   return <div>Your component</div>;

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

@@ -1,4 +1,5 @@
-import { DemoObjectStorageConfig, IObjectStorage, ObjectMetadata, ObjectData, StoredObject, MonitorCallback, DemonitorFunction, AddOptions, ObjectMetadataWithId } from './types';
+import { DemoObjectStorageConfig, IObjectStorage, MonitorCallback, DemonitorFunction, StoredObjectMetadataWithId } from './types';
+import { StoredObject, StoredObjectMetadata, StoredObjectData } from './stored-object';
 export declare class DemoObjectStorage implements IObjectStorage {
     private config;
     private objects;
@@ -8,18 +9,18 @@ export declare class DemoObjectStorage implements IObjectStorage {
     /**
      * Lists metadata documents for objects associated with specific question IDs
      */
-    list(questionId: string): Promise<ObjectMetadataWithId[]>;
+    list(questionId: string): Promise<StoredObjectMetadataWithId[]>;
     /**
      * 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(questionId: string, callback: MonitorCallback): DemonitorFunction;
+    monitor(questionId: string, callback: MonitorCallback): Promise<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
+     * Returns the StoredObject that was added
      */
-    add(object: StoredObject, options?: AddOptions): Promise<string>;
+    add(object: StoredObject): Promise<StoredObject>;
     /**
      * Reads both metadata and data documents for an object
      * Returns undefined if the object is not found
@@ -29,16 +30,17 @@ export declare class DemoObjectStorage implements IObjectStorage {
      * Reads only the metadata document for an object
      * Returns undefined if the object is not found
      */
-    readMetadata(objectId: string): Promise<ObjectMetadata | undefined>;
+    readMetadata(objectId: string): Promise<StoredObjectMetadata | undefined>;
     /**
      * Reads only the data document for an object
      * Returns undefined if the object is not found
      */
-    readData(objectId: string): Promise<ObjectData | undefined>;
+    readData(objectId: string): Promise<StoredObjectData | undefined>;
     /**
-     * Generates a new unique ID using nanoid
+     * Reads a single data item for an object
+     * Returns undefined if the object or item is not found
      */
-    genId(): string;
+    readDataItem(objectId: string, itemId: string): Promise<any | undefined>;
     /**
      * Notifies all active monitors of changes
      */

package/dist/demo-object-storage.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DemoObjectStorage = void 0;
-const nanoid_1 = require("nanoid");
 class DemoObjectStorage {
     constructor(config) {
         if (config.version !== 1) {
@@ -29,7 +28,7 @@ class DemoObjectStorage {
      * Invokes callback at start and on any change
      * Returns a function to stop monitoring
      */
-    monitor(questionId, callback) {
+    async monitor(questionId, callback) {
         if (!this.monitors.has(questionId)) {
             this.monitors.set(questionId, []);
         }
@@ -48,28 +47,21 @@ class DemoObjectStorage {
     }
     /**
      * Adds both metadata and data documents for a new object
-     * Returns the generated object ID (nanoid) or the provided ID if specified in options
+     * Returns the StoredObject that was added
      */
-    async add(object, options) {
-        const id = options?.id ?? (0, nanoid_1.nanoid)();
+    async add(object) {
+        const id = object.id;
         this.objects.set(id, object);
         // Notify all monitors
         this.notifyMonitors();
-        return id;
+        return object;
     }
     /**
      * Reads both metadata and data documents for an object
      * Returns undefined if the object is not found
      */
     async read(objectId) {
-        const obj = this.objects.get(objectId);
-        if (!obj) {
-            return undefined;
-        }
-        return {
-            metadata: obj.metadata,
-            data: obj.data
-        };
+        return this.objects.get(objectId);
     }
     /**
      * Reads only the metadata document for an object
@@ -94,10 +86,15 @@ class DemoObjectStorage {
         return obj.data;
     }
     /**
-     * Generates a new unique ID using nanoid
+     * Reads a single data item for an object
+     * Returns undefined if the object or item is not found
      */
-    genId() {
-        return (0, nanoid_1.nanoid)();
+    async readDataItem(objectId, itemId) {
+        const obj = this.objects.get(objectId);
+        if (!obj) {
+            return undefined;
+        }
+        return obj.data[itemId];
     }
     /**
      * Notifies all active monitors of changes

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

@@ -1,6 +1,7 @@
 import "firebase/compat/auth";
 import "firebase/compat/firestore";
-import { FirebaseObjectStorageConfig, IObjectStorage, ObjectMetadata, ObjectData, StoredObject, MonitorCallback, DemonitorFunction, AddOptions, ObjectMetadataWithId } from './types';
+import { FirebaseObjectStorageConfig, IObjectStorage, MonitorCallback, DemonitorFunction, StoredObjectMetadataWithId } from './types';
+import { StoredObject, StoredObjectMetadata, StoredObjectData } from './stored-object';
 export declare class FirebaseObjectStorage implements IObjectStorage {
     private config;
     private initPromise;
@@ -12,6 +13,7 @@ export declare class FirebaseObjectStorage implements IObjectStorage {
     private createDocument;
     private getPaths;
     private getRefs;
+    private getItemDataPath;
     private getMetadataQuery;
     /**
      * Ensures the provided ID is in question ID format as opposed to reference ID format
@@ -25,18 +27,18 @@ export declare class FirebaseObjectStorage implements IObjectStorage {
     /**
      * Lists metadata documents for objects associated with specific question IDs
      */
-    list(questionOrRefId: string): Promise<ObjectMetadataWithId[]>;
+    list(questionOrRefId: string): Promise<StoredObjectMetadataWithId[]>;
     /**
      * 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(questionOrRefId: string, callback: MonitorCallback): DemonitorFunction;
+    monitor(questionOrRefId: string, callback: MonitorCallback): Promise<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
+     * Returns the StoredObject that was added
      */
-    add(object: StoredObject, options?: AddOptions): Promise<string>;
+    add(object: StoredObject): Promise<StoredObject>;
     /**
      * Reads both metadata and data documents for an object
      */
@@ -44,13 +46,13 @@ export declare class FirebaseObjectStorage implements IObjectStorage {
     /**
      * Reads only the metadata document for an object
      */
-    readMetadata(objectId: string): Promise<ObjectMetadata | undefined>;
+    readMetadata(objectId: string): Promise<StoredObjectMetadata | undefined>;
     /**
      * Reads only the data document for an object
      */
-    readData(objectId: string): Promise<ObjectData | undefined>;
+    readData(objectId: string): Promise<StoredObjectData | undefined>;
     /**
-     * Generates a new unique ID using nanoid
+     * Reads a single data item for an object
      */
-    genId(): string;
+    readDataItem(objectId: string, itemId: string): Promise<any | undefined>;
 }

package/dist/firebase-object-storage.js

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (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");
+const stored_object_1 = require("./stored-object");
 class FirebaseObjectStorage {
     constructor(config) {
         this.initialized = false;
@@ -74,6 +74,9 @@ class FirebaseObjectStorage {
         const dataRef = this.app.firestore().doc(dataPath);
         return { metadataRef, dataRef };
     }
+    getItemDataPath(objectId, itemId) {
+        return `${this.config.root}/object_store_data/${objectId}-${itemId}`;
+    }
     getMetadataQuery(questionOrRefId) {
         const questionId = this.ensureIdIsQuestionId(questionOrRefId);
         const { metadataPath } = this.getPaths();
@@ -129,8 +132,8 @@ class FirebaseObjectStorage {
      * Invokes callback at start and on any change
      * Returns a function to stop monitoring
      */
-    monitor(questionOrRefId, callback) {
-        // await this.ensureInitialized();
+    async monitor(questionOrRefId, callback) {
+        await this.ensureInitialized();
         const query = this.getMetadataQuery(questionOrRefId);
         const unsub = query.onSnapshot(snapshot => {
             const results = [];
@@ -145,20 +148,29 @@ class FirebaseObjectStorage {
     }
     /**
      * Adds both metadata and data documents for a new object
-     * Returns the generated object ID (nanoid) or the provided ID if specified in options
+     * Returns the StoredObject that was added
      */
-    async add(object, options) {
+    async add(object) {
         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 newObjectId = object.id;
+        const { metadata } = object;
+        const { metadataRef } = this.getRefs(newObjectId);
         const metadataDoc = this.createDocument({ metadata });
         const batch = this.app.firestore().batch();
-        batch.set(dataRef, dataDoc);
         batch.set(metadataRef, metadataDoc);
+        // Write each item as a separate document
+        for (const itemId in object.data) {
+            const itemPath = this.getItemDataPath(newObjectId, itemId);
+            const itemRef = this.app.firestore().doc(itemPath);
+            const itemDoc = this.createDocument({
+                objectId: newObjectId,
+                itemId: itemId,
+                itemData: JSON.stringify(object.data[itemId])
+            });
+            batch.set(itemRef, itemDoc);
+        }
         await batch.commit();
-        return newObjectId;
+        return object;
     }
     /**
      * Reads both metadata and data documents for an object
@@ -173,7 +185,7 @@ class FirebaseObjectStorage {
         if (!data) {
             return undefined;
         }
-        return { metadata, data };
+        return stored_object_1.StoredObject.FromParts(objectId, metadata, data);
     }
     /**
      * Reads only the metadata document for an object
@@ -185,25 +197,44 @@ class FirebaseObjectStorage {
         if (!metadataSnapshot.exists) {
             return undefined;
         }
-        return metadataSnapshot.data()?.metadata ?? {};
+        return metadataSnapshot.data()?.metadata;
     }
     /**
      * Reads only the data document for an object
      */
     async readData(objectId) {
         await this.ensureInitialized();
-        const { dataRef } = this.getRefs(objectId);
-        const dataSnapshot = await dataRef.get();
-        if (!dataSnapshot.exists) {
+        const dataPath = `${this.config.root}/object_store_data`;
+        const query = this.app.firestore().collection(dataPath)
+            .where("objectId", "==", objectId);
+        const querySnapshot = await query.get();
+        if (querySnapshot.empty) {
             return undefined;
         }
-        return dataSnapshot.data()?.data ?? {};
+        const data = {};
+        querySnapshot.forEach(doc => {
+            const docData = doc.data();
+            const itemId = docData.itemId;
+            const itemDataString = docData.itemData;
+            if (itemId && itemDataString) {
+                data[itemId] = JSON.parse(itemDataString);
+            }
+        });
+        return data;
     }
     /**
-     * Generates a new unique ID using nanoid
+     * Reads a single data item for an object
      */
-    genId() {
-        return (0, nanoid_1.nanoid)();
+    async readDataItem(objectId, itemId) {
+        await this.ensureInitialized();
+        const itemPath = this.getItemDataPath(objectId, itemId);
+        const itemRef = this.app.firestore().doc(itemPath);
+        const itemSnapshot = await itemRef.get();
+        if (!itemSnapshot.exists) {
+            return undefined;
+        }
+        const itemDataString = itemSnapshot.data()?.itemData;
+        return itemDataString ? JSON.parse(itemDataString) : undefined;
     }
 }
 exports.FirebaseObjectStorage = FirebaseObjectStorage;

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, FirebaseObjectStorageUser, FirebaseObjectStorageConfig, ObjectMetadata, ObjectData, StoredObject, ObjectWithId, MonitorCallback, DemonitorFunction } from './types';
-export * from './typed-object';
+export { IObjectStorage, ObjectStorageConfig, DemoObjectStorageConfig, FirebaseObjectStorageUser, FirebaseObjectStorageConfig, StoredObjectWithId as ObjectWithId, MonitorCallback, DemonitorFunction } from './types';
+export * from './stored-object';

package/dist/index.js

@@ -24,4 +24,4 @@ Object.defineProperty(exports, "createObjectStorage", { enumerable: true, get: f
 var object_storage_context_1 = require("./object-storage-context");
 Object.defineProperty(exports, "ObjectStorageProvider", { enumerable: true, get: function () { return object_storage_context_1.ObjectStorageProvider; } });
 Object.defineProperty(exports, "useObjectStorage", { enumerable: true, get: function () { return object_storage_context_1.useObjectStorage; } });
-__exportStar(require("./typed-object"), exports);
+__exportStar(require("./stored-object"), exports);

package/dist/stored-object.d.ts

@@ -0,0 +1,74 @@
+export type AddImageOptions = {
+    id?: string;
+    name: string;
+    url: string;
+    width?: number;
+    height?: number;
+    description?: string;
+    subType?: string;
+};
+export type AddDataTableOptions = {
+    id?: string;
+    name: string;
+    cols: string[];
+    rows: any[][];
+    description?: string;
+    subType?: string;
+};
+export type AddTextOptions = {
+    id?: string;
+    name: string;
+    text: string;
+    description?: string;
+    subType?: string;
+};
+export type AddStoredObjectOptions = {
+    id?: string;
+    name: string;
+    data: Record<string, any>;
+    description?: string;
+    subType?: string;
+};
+export type StoredImageMetadata = {
+    type: "image";
+} & Omit<AddImageOptions, "id" | "url">;
+export type StoredObjectDataTableMetadata = {
+    type: "dataTable";
+} & Omit<AddDataTableOptions, "id" | "rows">;
+export type StoredTextMetadata = {
+    type: "text";
+} & Omit<AddTextOptions, "id" | "text">;
+export type StoredObjectItemMetadata = {
+    type: "object";
+    keys: string[];
+} & Omit<AddStoredObjectOptions, "id" | "data">;
+export type StoredMetadataItem = StoredImageMetadata | StoredObjectDataTableMetadata | StoredTextMetadata | StoredObjectItemMetadata;
+export type StoredMetadataItems = Record<string, StoredMetadataItem>;
+export type StoredObjectType = "simulation-recording" | "untyped";
+export type StoredObjectMetadata = {
+    version: 1;
+    type: StoredObjectType;
+    subType?: string;
+    items: StoredMetadataItems;
+    name?: string;
+    description?: string;
+};
+export type StoredObjectData = Record<string, any>;
+export type StoredObjectOptions = {
+    id?: string;
+    name?: string;
+    description?: string;
+    type?: StoredObjectType;
+    subType?: string;
+};
+export declare class StoredObject {
+    id: string;
+    metadata: StoredObjectMetadata;
+    data: StoredObjectData;
+    constructor(options?: StoredObjectOptions);
+    static FromParts(id: string, metadata: StoredObjectMetadata, data: StoredObjectData): StoredObject;
+    addImage(options: AddImageOptions): void;
+    addDataTable(options: AddDataTableOptions): void;
+    addText(options: AddTextOptions): void;
+    addObject(options: AddStoredObjectOptions): void;
+}

package/dist/stored-object.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoredObject = void 0;
+const nanoid_1 = require("nanoid");
+class StoredObject {
+    constructor(options) {
+        this.id = options?.id || (0, nanoid_1.nanoid)();
+        this.metadata = {
+            version: 1,
+            type: options?.type || "untyped",
+            items: {},
+        };
+        if (options?.name !== undefined) {
+            this.metadata.name = options.name;
+        }
+        if (options?.description !== undefined) {
+            this.metadata.description = options.description;
+        }
+        if (options?.subType !== undefined) {
+            this.metadata.subType = options.subType;
+        }
+        this.data = {};
+    }
+    static FromParts(id, metadata, data) {
+        const typedObject = new StoredObject({ id });
+        typedObject.metadata = metadata;
+        typedObject.data = data;
+        return typedObject;
+    }
+    addImage(options) {
+        const id = options.id || (0, nanoid_1.nanoid)();
+        this.metadata.items[id] = {
+            type: "image",
+            name: options.name
+        };
+        if (options.subType !== undefined) {
+            this.metadata.items[id].subType = options.subType;
+        }
+        if (options.width !== undefined) {
+            this.metadata.items[id].width = options.width;
+        }
+        if (options.height !== undefined) {
+            this.metadata.items[id].height = options.height;
+        }
+        if (options.description !== undefined) {
+            this.metadata.items[id].description = options.description;
+        }
+        this.data[id] = {
+            url: options.url
+        };
+    }
+    addDataTable(options) {
+        const id = options.id || (0, nanoid_1.nanoid)();
+        this.metadata.items[id] = {
+            type: "dataTable",
+            name: options.name,
+            cols: options.cols,
+        };
+        if (options.subType !== undefined) {
+            this.metadata.items[id].subType = options.subType;
+        }
+        if (options.description !== undefined) {
+            this.metadata.items[id].description = options.description;
+        }
+        this.data[id] = {
+            rows: options.rows
+        };
+    }
+    addText(options) {
+        const id = options.id || (0, nanoid_1.nanoid)();
+        this.metadata.items[id] = {
+            type: "text",
+            name: options.name,
+        };
+        if (options.subType !== undefined) {
+            this.metadata.items[id].subType = options.subType;
+        }
+        if (options.description !== undefined) {
+            this.metadata.items[id].description = options.description;
+        }
+        this.data[id] = {
+            text: options.text
+        };
+    }
+    addObject(options) {
+        const id = options.id || (0, nanoid_1.nanoid)();
+        this.metadata.items[id] = {
+            type: "object",
+            name: options.name,
+            keys: Object.keys(options.data),
+        };
+        if (options.subType !== undefined) {
+            this.metadata.items[id].subType = options.subType;
+        }
+        if (options.description !== undefined) {
+            this.metadata.items[id].description = options.description;
+        }
+        this.data[id] = options.data;
+    }
+}
+exports.StoredObject = StoredObject;

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { StoredObject, StoredObjectMetadata, StoredObjectData } from './stored-object';
 export interface DemoObjectStorageConfig {
     version: 1;
     type: "demo";
@@ -24,40 +25,27 @@ export interface FirebaseObjectStorageConfig {
     questionId: string;
 }
 export type ObjectStorageConfig = DemoObjectStorageConfig | FirebaseObjectStorageConfig;
-export interface AddOptions {
-    id?: string;
-}
 export interface IObjectStorage {
-    list(questionOrRefId: string): Promise<ObjectMetadataWithId[]>;
-    monitor(questionOrRefId: string, callback: MonitorCallback): DemonitorFunction;
-    add(object: StoredObject, options?: AddOptions): Promise<string>;
+    list(questionOrRefId: string): Promise<StoredObjectMetadataWithId[]>;
+    monitor(questionOrRefId: string, callback: MonitorCallback): Promise<DemonitorFunction>;
+    add(object: StoredObject): Promise<StoredObject>;
     read(objectId: string): Promise<StoredObject | undefined>;
-    readMetadata(objectId: string): Promise<ObjectMetadata | undefined>;
-    readData(objectId: string): Promise<ObjectData | undefined>;
-    genId(): string;
-}
-export interface ObjectMetadata {
-    [key: string]: any;
-}
-export interface ObjectData {
-    [key: string]: any;
-}
-export interface StoredObject {
-    metadata: ObjectMetadata;
-    data: ObjectData;
+    readMetadata(objectId: string): Promise<StoredObjectMetadata | undefined>;
+    readData(objectId: string): Promise<StoredObjectData | undefined>;
+    readDataItem(objectId: string, itemId: string): Promise<any | undefined>;
 }
-export interface ObjectMetadataWithId {
+export interface StoredObjectMetadataWithId {
     id: string;
-    metadata: ObjectMetadata;
+    metadata: StoredObjectMetadata;
 }
-export interface ObjectDataWithId {
+export interface StoredObjectDataWithId {
     id: string;
-    data: ObjectData;
+    data: StoredObjectData;
 }
-export interface ObjectWithId {
+export interface StoredObjectWithId {
     id: string;
-    metadata: ObjectMetadata;
-    data: ObjectData;
+    metadata: StoredObjectMetadata;
+    data: StoredObjectData;
 }
-export type MonitorCallback = (objects: ObjectMetadataWithId[]) => void;
+export type MonitorCallback = (objects: StoredObjectMetadataWithId[]) => void;
 export type DemonitorFunction = () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@concord-consortium/object-storage",
-  "version": "1.0.0-pre.6",
+  "version": "1.0.0-pre.8",
   "description": "A TypeScript library for object storage",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,8 +10,8 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
-    "prepublishOnly": "npm run build",
-    "publish": "npm publish"
+    "prepare": "tsc",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "object-storage",