@data-weave/backend-firestore 0.4.5 → 0.4.7

package/lib/backend-firestore/src/FirestoreDataManager.d.ts

@@ -0,0 +1,45 @@
+import { Cache, DataManager, IdentifiableReference, List, ListPaginationParams, WithMetadata, WithoutId } from '@data-weave/datamanager';
+import { FirestoreList, FirestoreListContext } from './FirestoreList';
+import { FirestoreSerializedMetadata } from './FirestoreMetadata';
+import { FirestoreReference, FirestoreReferenceContext } from './FirestoreReference';
+import { FilterBy, FirebaseCreateOptions, Firestore, FirestoreDataConverter, FirestoreReadMode, FirestoreReadOptions, FirestoreTypes, FirestoreWriteOptions, OrderBy, WithFieldValue } from './firestoreTypes';
+export type FirebaseDataManagerDeleteMode = 'soft' | 'hard';
+export interface FirebaseDataManagerOptions {
+    readonly idResolver?: () => string;
+    readonly deleteMode?: FirebaseDataManagerDeleteMode;
+    readonly readMode?: FirestoreReadMode;
+    readonly preventOverwriteOnCreate?: boolean;
+    readonly errorInterceptor?: (error: unknown, ctx: FirestoreReferenceContext | FirestoreListContext) => void;
+    readonly snapshotOptions?: FirestoreTypes.SnapshotOptions;
+    readonly Reference?: typeof FirestoreReference;
+    readonly List?: typeof FirestoreList;
+    readonly listCache?: Cache;
+    readonly refCache?: Cache;
+}
+export interface QueryParams<T extends FirestoreTypes.DocumentData> {
+    readonly filters?: Array<FilterBy<T & FirestoreSerializedMetadata>>;
+    readonly orderBy?: Array<OrderBy<T & FirestoreSerializedMetadata>>;
+}
+export declare class FirestoreDataManager<T extends FirestoreTypes.DocumentData, SerializedT extends FirestoreTypes.DocumentData = T> implements DataManager<T> {
+    private readonly firestore;
+    private readonly collectionPath;
+    private readonly converter;
+    private readonly opts?;
+    private mergedConverter;
+    private collection;
+    private collectionQuery;
+    private managerOptions;
+    private refCache;
+    private listCache;
+    constructor(firestore: Firestore, collectionPath: string, converter: FirestoreDataConverter<T, SerializedT>, opts?: FirebaseDataManagerOptions | undefined);
+    read(id: string, options?: FirestoreReadOptions): Promise<WithMetadata<T> | undefined>;
+    create(data: WithFieldValue<WithoutId<T>>, options?: FirebaseCreateOptions): Promise<IdentifiableReference<WithMetadata<T>>>;
+    private _update;
+    update(id: string, data: WithoutId<Partial<WithFieldValue<T>>>, options?: FirestoreWriteOptions): Promise<void>;
+    upsert(id: string, data: WithFieldValue<WithoutId<T>>, options?: FirestoreWriteOptions): Promise<void>;
+    delete(id: string, options?: FirestoreWriteOptions): Promise<void>;
+    getRef(id: string): IdentifiableReference<WithMetadata<T>>;
+    private _getFilteredQuery;
+    getList(params?: QueryParams<SerializedT> & ListPaginationParams): List<WithMetadata<T>>;
+    private preventOverwriteOnCreate;
+}

package/lib/{FirestoreDataManager.js → backend-firestore/src/FirestoreDataManager.js}

@@ -49,7 +49,7 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirestoreDataManager = void 0;
 const inversify_1 = require("inversify");
-const Cache_1 = require("@data-weave/datamanager/src/Cache");
+const datamanager_1 = require("@data-weave/datamanager");
 const FirestoreList_1 = require("./FirestoreList");
 const FirestoreMetadata_1 = require("./FirestoreMetadata");
 const FirestoreReference_1 = require("./FirestoreReference");
@@ -75,8 +75,8 @@ let FirestoreDataManager = (() => {
             // @ts-expect-error - Force merge FirestoreDataConverter and InternalFirestoreDataConverter
             this.mergedConverter = new utils_1.MergeConverters(this.converter, new FirestoreMetadata_1.FirestoreMetadataConverter());
             this.managerOptions = Object.assign(defaultFirebaseDataManagerOptions, this.opts);
-            this.refCache = this.managerOptions.refCache || new Cache_1.MapCache(100);
-            this.listCache = this.managerOptions.listCache || new Cache_1.MapCache(100);
+            this.refCache = this.managerOptions.refCache || new datamanager_1.MapCache(100);
+            this.listCache = this.managerOptions.listCache || new datamanager_1.MapCache(100);
             this.collection = this.firestore
                 .collection(this.firestore.app, this.collectionPath)
                 .withConverter(this.mergedConverter);

package/lib/backend-firestore/src/FirestoreList.d.ts

@@ -0,0 +1,23 @@
+import { ListPaginationParams, LiveList, LiveListOptions } from '@data-weave/datamanager';
+import { DocumentData, Firestore, FirestoreReadMode, FirestoreTypes } from './firestoreTypes';
+export interface FirestoreListContext {
+    query: FirestoreTypes.Query<unknown>;
+    readMode?: FirestoreReadMode;
+    type: 'list';
+}
+export interface FirestoreListOptions<T> extends LiveListOptions<T> {
+    readMode?: FirestoreReadMode;
+    errorInterceptor?: (error: unknown, ctx: FirestoreListContext) => void;
+}
+export declare class FirestoreList<T extends DocumentData, S extends DocumentData> extends LiveList<T> {
+    private readonly firestore;
+    private readonly query;
+    private readonly options;
+    private unsubscribeFromSnapshot;
+    constructor(firestore: Firestore, query: FirestoreTypes.Query<T, S>, options: FirestoreListOptions<T> & ListPaginationParams);
+    resolve(): Promise<T[]>;
+    protected handleInitialDataChange(values: FirestoreTypes.QueryDocumentSnapshot<T, S>[]): void;
+    protected handleSubsequentDataChanges(changes: FirestoreTypes.DocumentChange<T, S>[]): void;
+    unSubscribe(): void;
+    protected onError(error: unknown): void;
+}

package/lib/{FirestoreList.js → backend-firestore/src/FirestoreList.js}

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirestoreList = void 0;
-const src_1 = require("@data-weave/datamanager/src");
-class FirestoreList extends src_1.LiveList {
+const datamanager_1 = require("@data-weave/datamanager");
+class FirestoreList extends datamanager_1.LiveList {
     constructor(firestore, query, options) {
         super(options);
         this.firestore = firestore;

package/lib/backend-firestore/src/FirestoreMetadata.d.ts

@@ -0,0 +1,32 @@
+import { Metadata, WithoutId } from '@data-weave/datamanager';
+import { DocumentData, FirestoreQuery, FirestoreTypes, FirestoreWhere, InternalFirestoreDataConverter, WithFieldValue } from './firestoreTypes';
+declare enum FIRESTORE_INTERAL_KEYS {
+    DELETED = "__deleted",
+    CREATED_AT = "__createdAt",
+    UPDATED_AT = "__updatedAt"
+}
+export declare enum FIRESTORE_KEYS {
+    DELETED = "deleted",
+    CREATED_AT = "createdAt",
+    UPDATED_AT = "updatedAt"
+}
+export type FirestoreSerializedMetadata = {
+    [FIRESTORE_INTERAL_KEYS.DELETED]: boolean;
+    [FIRESTORE_INTERAL_KEYS.CREATED_AT]: FirestoreTypes.Timestamp;
+    [FIRESTORE_INTERAL_KEYS.UPDATED_AT]: FirestoreTypes.Timestamp;
+};
+export declare class FirestoreMetadataConverter implements InternalFirestoreDataConverter<Metadata, FirestoreSerializedMetadata> {
+    toFirestore(data: WithFieldValue<WithoutId<Metadata>>): {
+        __deleted: FirestoreTypes.FieldValue | FirestoreTypes.WithFieldValue<boolean>;
+        __createdAt: FirestoreTypes.Timestamp;
+        __updatedAt: FirestoreTypes.Timestamp;
+    };
+    fromFirestore(snapshot: FirestoreTypes.QueryDocumentSnapshot<DocumentData, DocumentData>, options: FirestoreTypes.SnapshotOptions): {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        deleted: boolean;
+    };
+}
+export declare const queryNotDeleted: <T extends DocumentData, SerializedT extends DocumentData>(query: FirestoreTypes.Query<T, SerializedT>, firestoreQuery: FirestoreQuery<T, SerializedT>, firestoreWhere: FirestoreWhere) => FirestoreTypes.Query<T, SerializedT>;
+export {};

package/lib/backend-firestore/src/FirestoreReference.d.ts

@@ -0,0 +1,27 @@
+import { LiveReference, LiveReferenceOptions } from '@data-weave/datamanager';
+import { DocumentData, Firestore, FirestoreReadMode, FirestoreTypes } from './firestoreTypes';
+export interface FirestoreReferenceContext {
+    path: string;
+    id: string;
+    readMode?: FirestoreReadMode;
+    snapshotOptions?: FirestoreTypes.SnapshotOptions;
+    type: 'reference';
+}
+export interface FirestoreReferenceOptions<T> extends LiveReferenceOptions<T> {
+    readMode?: FirestoreReadMode;
+    snapshotOptions?: FirestoreTypes.SnapshotOptions;
+    errorInterceptor?: (error: unknown, ctx: FirestoreReferenceContext) => void;
+}
+export declare class FirestoreReference<T extends DocumentData, S extends DocumentData> extends LiveReference<T> {
+    private readonly firestore;
+    private readonly docRef;
+    readonly options: FirestoreReferenceOptions<T>;
+    private unsubscribeFromSnapshot;
+    constructor(firestore: Firestore, docRef: FirestoreTypes.DocumentReference<T, S>, options: FirestoreReferenceOptions<T>);
+    resolve(): Promise<T | undefined>;
+    get id(): string;
+    get path(): string;
+    protected onError(error: unknown): void;
+    unSubscribe(): void;
+    private parseDocumentSnapshot;
+}

package/lib/{FirestoreReference.js → backend-firestore/src/FirestoreReference.js}

@@ -10,9 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirestoreReference = void 0;
-const src_1 = require("@data-weave/datamanager/src");
+const datamanager_1 = require("@data-weave/datamanager");
 const utils_1 = require("./utils");
-class FirestoreReference extends src_1.LiveReference {
+class FirestoreReference extends datamanager_1.LiveReference {
     constructor(firestore, docRef, options) {
         super(options);
         this.firestore = firestore;

package/lib/backend-firestore/src/firestoreTypes.d.ts

@@ -0,0 +1,117 @@
+import { WithoutId } from '@data-weave/datamanager';
+import type * as FirestoreTypes from '@firebase/firestore';
+import type { FieldPath, WithFieldValue as FirestoreWithFieldValue, QueryConstraint } from '@firebase/firestore';
+import type { HttpsCallable, HttpsCallableOptions } from '@firebase/functions-types';
+import { FieldValue, Transaction } from '@google-cloud/firestore';
+export type DocumentData = FirestoreTypes.DocumentData;
+export { FieldValue, FirestoreTypes, Transaction };
+/**
+ * Same as Partial but all fields are required to be included
+ */
+type OptionallyUndefined<T> = {
+    [P in keyof T]: T[P] | undefined;
+};
+export declare interface InternalFirestoreDataConverter<T extends DocumentData, SerializedT extends DocumentData = DocumentData> {
+    toFirestore(modelObject: Partial<WithFieldValue<WithoutId<T>>>, options?: FirestoreTypes.SetOptions): WithFieldValue<WithoutId<SerializedT>>;
+    fromFirestore(snapshot: FirestoreTypes.QueryDocumentSnapshot<T, SerializedT>, options?: FirestoreTypes.SnapshotOptions): T;
+}
+export type WithTimestamps<T> = {
+    [K in keyof T]: T[K] extends Date ? FirestoreTypes.Timestamp : T[K] extends Date | null ? FirestoreTypes.Timestamp | null : T[K] extends Date | undefined ? FirestoreTypes.Timestamp | undefined : T[K] extends Date | null | undefined ? FirestoreTypes.Timestamp | null | undefined : T[K] extends object ? T[K] extends any[] ? T[K] extends (infer U)[] ? WithTimestamps<U>[] : T[K] : WithTimestamps<T[K]> : T[K];
+};
+/**
+ * Converts data between model and serialized data. Differs from InternalFirestoreDataConverter
+ * by using `OptionallyUndefined` and `Required` to ensure that all fields are included in de/serialization
+ * even if some model defined properties are optional.
+ */
+export declare interface FirestoreDataConverter<ModelObject, SerializedModelObject = ModelObject> {
+    toFirestore(modelObject: WithoutId<ModelObject>, options?: FirestoreTypes.SetOptions): OptionallyUndefined<Required<WithoutId<WithFieldValue<SerializedModelObject>>>>;
+    fromFirestore(snapshot: FirestoreTypes.QueryDocumentSnapshot<WithTimestamps<SerializedModelObject>>, options?: FirestoreTypes.SnapshotOptions): ModelObject;
+}
+export type FirestoreQuery<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> = (reference: FirestoreTypes.Query<AppModelType, DbModelType>, filter: any) => FirestoreTypes.Query<AppModelType, DbModelType>;
+export type FirestoreWhere = (field: string | FieldPath, op: string, value: unknown) => any;
+export type FirestoreReadMode = 'realtime' | 'static';
+export interface FirestoreReadOptions {
+    readonly transaction?: FirestoreTypes.Transaction;
+}
+export interface FirestoreWriteOptions {
+    readonly transaction?: FirestoreTypes.Transaction;
+    readonly batcher?: FirestoreTypes.WriteBatch;
+}
+export interface FirebaseCreateOptions extends FirestoreWriteOptions {
+    id?: string;
+    merge?: boolean;
+}
+export declare type WithFieldValue<T> = {
+    [K in keyof T]: FirestoreWithFieldValue<T[K]> | FirestoreTypes.FieldValue;
+};
+type GenNode<K extends string, IsRoot extends boolean> = IsRoot extends true ? `${K}` : `.${K}`;
+export type FilterableFields<T extends object, IsRoot extends boolean = true, K extends keyof T = keyof T> = K extends string ? T[K] extends FirestoreTypes.Timestamp ? `${K}` : T[K] extends Date ? `${K}` : T[K] extends any[] ? GenNode<K, IsRoot> : T[K] extends object ? `${GenNode<K, IsRoot>}${FilterableFields<T[K], false>}` : GenNode<K, IsRoot> : never;
+type GetValue<T, K extends string> = K extends `${infer L}.${infer R}` ? L extends keyof T ? GetValue<T[L], R> : never : K extends keyof T ? T[K] extends Date ? Date | FirestoreTypes.Timestamp : T[K] : K extends string ? string | number | boolean : never;
+export type PrimitiveFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>';
+export type FilterBy<T extends object, Field extends string = FilterableFields<T>> = Field extends string ? GetValue<T, Field> extends any[] ? [Field, 'array-contains', string] | [Field, 'array-contains-any', string[]] : [Field, PrimitiveFilterOp, GetValue<T, Field>] | [Field, 'in', string[]] : never;
+export type OrderBy<T extends DocumentData, Fields extends string = FilterableFields<T>> = [
+    Fields,
+    FirestoreTypes.OrderByDirection
+];
+export declare abstract class FieldValues {
+    abstract serverTimestamp(): FirestoreTypes.FieldValue;
+    abstract delete(): FirestoreTypes.FieldValue;
+    abstract increment(n: number): FirestoreTypes.FieldValue;
+    abstract arrayUnion(...elements: any[]): FirestoreTypes.FieldValue;
+    abstract arrayRemove(...elements: any[]): FirestoreTypes.FieldValue;
+}
+/**********
+ *
+ *
+ * INJECTABLES
+ *
+ *
+ * **********/
+export interface FirestoreAppSettings {
+    persistence?: boolean;
+    cacheSizeBytes?: number;
+    host?: string;
+    ssl?: boolean;
+    ignoreUndefinedProperties?: boolean;
+    serverTimestampBehavior?: 'estimate' | 'previous' | 'none';
+}
+export declare abstract class FirestoreApp {
+    abstract type?: string;
+    abstract toJSON?(): object;
+    abstract terminate?(): Promise<void>;
+    abstract settings?(settings: FirestoreAppSettings): void;
+    abstract useEmulator?(host: string, port: number): void;
+    abstract runTransaction?<T>(updateFunction: (transaction: Transaction) => Promise<T>, options?: FirestoreTypes.TransactionOptions): Promise<T>;
+}
+export declare abstract class Firestore {
+    abstract app: FirestoreApp;
+    abstract collection(reference: FirestoreTypes.CollectionReference | FirestoreApp, path: string): any;
+    abstract getDocs<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.Query<AppModelType, DbModelType>): Promise<FirestoreTypes.QuerySnapshot<AppModelType, DbModelType>>;
+    abstract getDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>, path?: string): Promise<FirestoreTypes.DocumentSnapshot<AppModelType, DbModelType>>;
+    abstract serverTimestamp(): FirestoreTypes.FieldValue;
+    abstract increment(n: number): FirestoreTypes.FieldValue;
+    abstract query<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.Query<AppModelType, DbModelType>, filter: any): FirestoreTypes.Query<AppModelType, DbModelType>;
+    abstract where(field: string | FieldPath, op: string, value: unknown): QueryConstraint;
+    abstract limit(limit: number): any;
+    abstract orderBy(orderBy: string, direction: FirestoreTypes.OrderByDirection): any;
+    abstract setDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>, data: any, options?: FirestoreTypes.SetOptions): Promise<void>;
+    abstract updateDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>, data: any): Promise<void>;
+    abstract doc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.Query<AppModelType, DbModelType>, path?: string): FirestoreTypes.DocumentReference<AppModelType, DbModelType>;
+    abstract deleteDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>): Promise<void>;
+    abstract onSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>, onNext: (snapshot: FirestoreTypes.DocumentSnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void): () => void;
+    abstract onSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(reference: FirestoreTypes.Query<AppModelType, DbModelType>, onNext: (snapshot: FirestoreTypes.QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void): () => void;
+    abstract runTransaction<T>(firestore: FirestoreApp, transaction: (transaction: Transaction) => Promise<T>, options?: FirestoreTypes.TransactionOptions): Promise<T>;
+}
+export declare abstract class FirestoreSettings {
+    abstract readMode: FirestoreReadMode;
+}
+export declare abstract class FirestoreFunctions {
+    abstract httpsCallable(name: string, options?: HttpsCallableOptions): HttpsCallable;
+    abstract useEmulator(host: string, port: number): void;
+    abstract useFunctionsEmulator(origin: string): void;
+}
+export declare class DummyFirestoreFunctions implements FirestoreFunctions {
+    httpsCallable(): HttpsCallable;
+    useEmulator(): void;
+    useFunctionsEmulator(): void;
+}

package/lib/backend-firestore/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './FirestoreDataManager';
+export * from './FirestoreList';
+export * from './FirestoreMetadata';
+export * from './FirestoreReference';
+export * from './firestoreTypes';
+export * from './utils';

package/lib/backend-firestore/src/utils.d.ts

@@ -0,0 +1,14 @@
+import { WithoutId } from '@data-weave/datamanager';
+import { DocumentData, Firestore, FirestoreTypes, InternalFirestoreDataConverter, Transaction, WithFieldValue } from './firestoreTypes';
+import { Firestore as FirebaseFirestore } from 'firebase/firestore';
+export declare class MergeConverters<T extends DocumentData, SerializedT extends DocumentData, G extends DocumentData, SerializedG extends DocumentData> implements InternalFirestoreDataConverter<T & G, SerializedT & SerializedG> {
+    private converter1;
+    private converter2;
+    constructor(converter1: InternalFirestoreDataConverter<T, SerializedT>, converter2: InternalFirestoreDataConverter<G, SerializedG>);
+    toFirestore(modelObject: WithoutId<Partial<WithFieldValue<T>>> & WithoutId<Partial<WithFieldValue<G>>>, options?: FirestoreTypes.SetOptions): WithFieldValue<WithoutId<SerializedT>> & WithFieldValue<WithoutId<SerializedG>>;
+    fromFirestore(snapshot: FirestoreTypes.QueryDocumentSnapshot<T & G, SerializedT & SerializedG>, options: FirestoreTypes.SnapshotOptions): T & G;
+}
+export declare function createModularFirestoreAdapter(firestore: FirebaseFirestore): Firestore;
+export declare const isFieldValue: (value: any) => value is FirestoreTypes.FieldValue;
+export declare const checkIfReferenceExists: (value: any) => boolean;
+export declare const withTransaction: (firestore: Firestore, transaction: (transaction: Transaction) => Promise<void>, options?: FirestoreTypes.TransactionOptions) => Promise<void>;

package/lib/backend-firestore/src/version.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: string;
+export = _exports;

package/lib/{version.js → backend-firestore/src/version.js}

@@ -1,3 +1,3 @@
 "use strict";
 // Generated by genversion.
-module.exports = '0.4.5';
+module.exports = '0.4.7';

package/lib/datamanager/src/Cache.d.ts

@@ -0,0 +1,15 @@
+export interface Cache<K = any, V = any> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+}
+export declare class MapCache<K, V> implements Cache<K, V> {
+    private cache;
+    private maxSize?;
+    constructor(maxSize?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+}

package/lib/datamanager/src/Cache.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapCache = void 0;
+class MapCache {
+    constructor(maxSize) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        return this.cache.get(key);
+    }
+    set(key, value) {
+        if (this.maxSize && this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            // Remove the first entry (oldest) when cache is full
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+exports.MapCache = MapCache;

package/lib/datamanager/src/DataManager.d.ts

@@ -0,0 +1,42 @@
+import { List } from './List';
+import { IdentifiableReference, WithoutId } from './Reference';
+export interface ReadOptions {
+    readonly transaction?: unknown;
+}
+export interface WriteOptions {
+    readonly transaction?: unknown;
+    readonly batcher?: unknown;
+}
+export interface CreateOptions extends WriteOptions {
+    id?: string;
+    merge?: boolean;
+}
+export type OrderByOption = 'asc' | 'desc';
+export interface GetListOptions {
+    readonly filterBy?: unknown;
+    readonly orderBy?: unknown;
+    readonly limit?: number;
+}
+export interface Metadata {
+    readonly id: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deleted: boolean;
+}
+export type WithMetadata<T> = T & Metadata;
+/**
+ * DataManager is the base class for all data managers.
+ * It is responsible for reading, creating, deleting, and updating data.
+ * It is also responsible for returning references and lists.
+ * It is generic and can be used for any type of data.
+ * @template T - The type of the data to be managed.
+ */
+export declare abstract class DataManager<T> {
+    abstract read(id: string): Promise<T | undefined>;
+    abstract create(data: WithoutId<T>, options?: CreateOptions): Promise<IdentifiableReference<WithMetadata<T>>>;
+    abstract delete(id: string): Promise<void>;
+    abstract update(id: string, data: Partial<WithoutId<T>>): Promise<void>;
+    abstract upsert(id: string, data: WithoutId<T>): Promise<void>;
+    abstract getRef(id: string): IdentifiableReference<WithMetadata<T>>;
+    abstract getList(params?: GetListOptions): List<WithMetadata<T>>;
+}

package/lib/datamanager/src/DataManager.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataManager = void 0;
+/**
+ * DataManager is the base class for all data managers.
+ * It is responsible for reading, creating, deleting, and updating data.
+ * It is also responsible for returning references and lists.
+ * It is generic and can be used for any type of data.
+ * @template T - The type of the data to be managed.
+ */
+class DataManager {
+}
+exports.DataManager = DataManager;

package/lib/datamanager/src/List.d.ts

@@ -0,0 +1,11 @@
+import { Resolvable } from './Reference';
+export interface ListPaginationParams {
+    readonly pageSize?: number;
+    readonly append?: boolean;
+    readonly loadFirstPageManually?: boolean;
+}
+export interface List<T> extends Resolvable<readonly T[]> {
+    readonly values: readonly T[];
+}
+export declare function createInitializedList<T>(values: ReadonlyArray<T>): List<T>;
+export declare function createEmptyList<T>(): List<T>;

package/lib/datamanager/src/List.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitializedList = createInitializedList;
+exports.createEmptyList = createEmptyList;
+function createInitializedList(values) {
+    return {
+        values,
+        resolved: true,
+        hasError: false,
+        resolve: () => __awaiter(this, void 0, void 0, function* () { return values; }),
+    };
+}
+function createEmptyList() {
+    return createInitializedList([]);
+}

package/lib/datamanager/src/LiveList.d.ts

@@ -0,0 +1,24 @@
+import { List } from './List';
+export interface LiveListOptions<T> {
+    onUpdate?: (newValues: T[]) => void;
+    onError?: (error: unknown) => void;
+}
+export declare class LiveList<T> implements List<T> {
+    private _values;
+    private _resolved;
+    private _hasError;
+    private _options;
+    constructor(options: LiveListOptions<T>);
+    resolve(): Promise<readonly T[]>;
+    get values(): T[];
+    get hasError(): boolean;
+    get resolved(): boolean;
+    protected setStale(): void;
+    protected onValuesChange(): void;
+    protected onUpdate(): void;
+    protected onUpdateAll(values: T[]): void;
+    protected onUpdateAtIndex(index: number, value: T): void;
+    protected onAddAtIndex(index: number, value: T): void;
+    protected onRemoveAtIndex(index: number): void;
+    protected onError(error: unknown): void;
+}

package/lib/datamanager/src/LiveList.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveList = void 0;
+class LiveList {
+    constructor(options) {
+        this._values = [];
+        this._resolved = false;
+        this._hasError = false;
+        this._options = options;
+    }
+    resolve() {
+        throw new Error('Method not implemented.');
+    }
+    get values() {
+        return this._values;
+    }
+    get hasError() {
+        return this._hasError;
+    }
+    get resolved() {
+        return this._resolved;
+    }
+    setStale() {
+        this._resolved = false;
+    }
+    onValuesChange() { }
+    onUpdate() {
+        var _a, _b;
+        this._resolved = true;
+        this.onValuesChange();
+        (_b = (_a = this._options).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, this._values);
+    }
+    onUpdateAll(values) {
+        this._values = values;
+        this.onUpdate();
+    }
+    onUpdateAtIndex(index, value) {
+        this._values[index] = value;
+    }
+    onAddAtIndex(index, value) {
+        this._values.splice(index, 0, value);
+    }
+    onRemoveAtIndex(index) {
+        this._values.splice(index, 1);
+    }
+    onError(error) {
+        var _a, _b;
+        this._hasError = true;
+        this._values = [];
+        this._resolved = true;
+        (_b = (_a = this._options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+        this.onValuesChange();
+    }
+}
+exports.LiveList = LiveList;

package/lib/datamanager/src/LiveReference.d.ts

@@ -0,0 +1,21 @@
+import { Reference } from './Reference';
+export interface LiveReferenceOptions<T> {
+    onUpdate?: (newValue: T | undefined) => void;
+    onError?: (error: unknown) => void;
+}
+export declare class LiveReference<T> implements Reference<T> {
+    readonly options: LiveReferenceOptions<T>;
+    private _value;
+    private _resolved;
+    private _hasError;
+    private _options;
+    resolve(): Promise<T | undefined>;
+    constructor(options: LiveReferenceOptions<T>);
+    get value(): T | undefined;
+    get resolved(): boolean;
+    get hasError(): boolean;
+    protected setStale(): void;
+    protected onUpdate(data: T | undefined): void;
+    protected onError(error: unknown): void;
+    protected onValueChange(): void;
+}

package/lib/datamanager/src/LiveReference.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveReference = void 0;
+class LiveReference {
+    resolve() {
+        throw new Error('Method not implemented.');
+    }
+    constructor(options) {
+        this.options = options;
+        this._resolved = false;
+        this._hasError = false;
+        this._value = undefined;
+        this._resolved = false;
+        this._hasError = false;
+        this._options = options;
+    }
+    get value() {
+        return this._value;
+    }
+    get resolved() {
+        return this._resolved;
+    }
+    get hasError() {
+        return this._hasError;
+    }
+    setStale() {
+        this._resolved = false;
+    }
+    onUpdate(data) {
+        var _a, _b;
+        this._value = data;
+        this._resolved = true;
+        this.onValueChange();
+        (_b = (_a = this._options).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, this._value);
+    }
+    onError(error) {
+        var _a, _b;
+        this._hasError = true;
+        this._value = undefined;
+        this._resolved = true;
+        this.onValueChange();
+        (_b = (_a = this._options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+    }
+    onValueChange() { }
+}
+exports.LiveReference = LiveReference;

package/lib/datamanager/src/Reference.d.ts

@@ -0,0 +1,15 @@
+export interface Identifiable {
+    readonly id: string;
+}
+export type WithoutId<T> = Omit<T, 'id'>;
+export interface Resolvable<T> {
+    readonly resolved: boolean;
+    readonly hasError: boolean;
+    resolve(): Promise<T>;
+}
+export interface Reference<T> extends Resolvable<T | undefined> {
+    readonly value: T | undefined;
+}
+export type IdentifiableReference<T> = Reference<T> & Identifiable;
+export declare function createInitializedIdentifiableReference<T>(value: T | undefined, id: string): Reference<T> & Identifiable;
+export declare function createEmptyIdentifiableReference<T>(id: string): Reference<T>;

package/lib/datamanager/src/Reference.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitializedIdentifiableReference = createInitializedIdentifiableReference;
+exports.createEmptyIdentifiableReference = createEmptyIdentifiableReference;
+function createInitializedIdentifiableReference(value, id) {
+    return {
+        id,
+        value,
+        resolved: true,
+        hasError: false,
+        resolve: () => __awaiter(this, void 0, void 0, function* () { return value; }),
+    };
+}
+function createEmptyIdentifiableReference(id) {
+    return createInitializedIdentifiableReference(undefined, id);
+}

package/lib/datamanager/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Cache';
+export * from './DataManager';
+export * from './List';
+export * from './LiveList';
+export * from './LiveReference';
+export * from './Reference';

package/lib/datamanager/src/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Cache"), exports);
+__exportStar(require("./DataManager"), exports);
+__exportStar(require("./List"), exports);
+__exportStar(require("./LiveList"), exports);
+__exportStar(require("./LiveReference"), exports);
+__exportStar(require("./Reference"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@data-weave/backend-firestore",
-    "version": "0.4.5",
+    "version": "0.4.7",
     "author": "",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
@@ -23,8 +23,8 @@
         "registry": "https://registry.npmjs.org/"
     },
     "peerDependencies": {
-        "@data-weave/datamanager": "0.4.3",
+        "@data-weave/datamanager": "0.4.6",
         "firebase": ">=11.0.0"
     },
-    "gitHead": "e78bab6280bc98003ab4dc48a4fda336b5c0f80f"
+    "gitHead": "09a715b9694113e389eedab5787a559c6e522a3a"
 }