@dereekb/firebase 5.2.0 → 6.0.0

package/src/lib/common/model/model.service.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inContextFirebaseModelsServiceFactory = exports.firebaseModelsService = exports.inContextFirebaseModelServiceFactory = exports.firebaseModelServiceFactory = exports.firebaseModelService = void 0;
+const util_1 = require("@dereekb/util");
+const model_loader_1 = require("./model/model.loader");
+const permission_1 = require("./permission");
+const permission_service_role_1 = require("./permission/permission.service.role");
+function firebaseModelService(config) {
+    const permissionServiceDelegate = (0, util_1.build)({
+        base: (0, model_loader_1.firebaseModelLoader)(config.getFirestoreCollection),
+        build: (x) => {
+            x.roleMapForModel = config.roleMapForModel;
+        }
+    });
+    const permissionService = (0, permission_1.firebaseModelPermissionService)(permissionServiceDelegate);
+    const service = {
+        roleMapForModelContext: (model, context) => permissionService.roleMapForModelContext(model, context),
+        roleMapForKeyContext: (key, context) => permissionService.roleMapForKeyContext(key, context),
+        loadModelForKey: permissionServiceDelegate.loadModelForKey
+    };
+    return service;
+}
+exports.firebaseModelService = firebaseModelService;
+function firebaseModelServiceFactory(config) {
+    return (0, util_1.cachedGetter)(() => firebaseModelService(config));
+}
+exports.firebaseModelServiceFactory = firebaseModelServiceFactory;
+function inContextFirebaseModelServiceFactory(factory) {
+    return (context) => {
+        const firebaseModelService = factory();
+        const base = (model) => {
+            const inModelContextService = {
+                model,
+                roleMap: () => service.roleMapForModel(model),
+                roleReader: () => (0, permission_service_role_1.contextGrantedModelRolesReader)(inModelContextService)
+            };
+            return inModelContextService;
+        };
+        const service = (0, util_1.build)({
+            base: base,
+            build: (x) => {
+                x.roleMapForModel = (model) => firebaseModelService.roleMapForModelContext(model, context);
+                x.roleMapForKey = (key) => firebaseModelService.roleMapForKeyContext(key, context);
+                x.loadModelForKey = (key) => firebaseModelService.loadModelForKey(key, context);
+            }
+        });
+        return service;
+    };
+}
+exports.inContextFirebaseModelServiceFactory = inContextFirebaseModelServiceFactory;
+/**
+ * Creates a new FirebaseModelsService.
+ *
+ * When a context is passed, it is extended and the services are available in the context too as a services function.
+ *
+ * This allows the services function to reference itself in usage. You do this by creating another type that extends the context. Example:
+ *
+ * export type DemoFirebaseBaseContext = FirebaseAppModelContext<DemoFirestoreCollections>;
+ * ...
+ * export const demoFirebaseModelServices = firebaseModelsService<typeof DEMO_FIREBASE_MODEL_SERVICE_FACTORIES, DemoFirebaseBaseContext, DemoFirebaseModelTypes>(DEMO_FIREBASE_MODEL_SERVICE_FACTORIES);
+ * export type DemoFirebaseContext = DemoFirebaseBaseContext & { service: typeof demoFirebaseModelServices };
+ *
+ * @param services
+ * @returns
+ */
+function firebaseModelsService(services) {
+    const firebaseModelsService = (type, context) => {
+        const firebaseModelService = services[type];
+        const contextWithService = Object.assign(Object.assign({}, context), { service: firebaseModelsService });
+        const service = inContextFirebaseModelServiceFactory(firebaseModelService)(contextWithService);
+        return service;
+    };
+    return firebaseModelsService;
+}
+exports.firebaseModelsService = firebaseModelsService;
+/**
+ * Creates a InContextFirebaseModelsServiceFactory for a particular service.
+ *
+ * @param service
+ * @returns
+ */
+function inContextFirebaseModelsServiceFactory(service) {
+    const inContextFirebaseModelsServiceFactory = (context) => {
+        return (type) => service(type, context);
+    };
+    return inContextFirebaseModelsServiceFactory;
+}
+exports.inContextFirebaseModelsServiceFactory = inContextFirebaseModelsServiceFactory;
+/*
+// TODO: there may be a way to set this up, and it would be ideal (to just pass in the model and get the model's collection name and return a properly typed object) but the collection name isn't available in typing so
+export interface InModelContextFirebaseModelsService<C, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole> extends InModelContextFirebaseModelPermissionService<C, T, D, R> {}
+export type InModelContextFirebaseModelsServiceFactory<Z, K extends FirestoreModelIdentity = FirestoreModelIdentity> = Z extends InContextFirebaseModelsService<infer Y> ? (Y extends FirebaseModelsService<infer X, infer C> ? (K extends keyof X ? (type: K) => X[K] extends FirebaseModelServiceGetter<C, infer T, infer D, infer R> ? (model: D) => InModelContextFirebaseModelsService<C, T, D, R> : never : never) : never) : never;
+
+export function inModelContextFirebaseModelsServiceFactory<Z extends InContextFirebaseModelsService<FirebaseModelsService<X, C>>, X extends FirebaseModelsServiceFactory<C, K>, C extends FirebaseModelServiceContext, K extends FirestoreModelIdentity = FirestoreModelIdentity>(firebaseModelsService: Z): InModelContextFirebaseModelsServiceFactory<FirebaseModelsService<X, C>, K> {
+  // the typings break down here when getting the intended FirestoreDocument type, but the InModelContextFirebaseModelServiceFactory will infer the correct typings in use.
+  const inModelContextFirebaseModelsServiceFactory: InModelContextFirebaseModelsServiceFactory<Z, K> = (<K extends keyof X, T, D extends FirestoreDocument<T>, R extends GrantedRole = GrantedRole>(model: D) => {
+
+    firebaseModelsService(model.modelType as K)
+
+      const inModelContextService: InModelContextFirebaseModelService<C, T, D, R> = {
+        roleMap: () => typeService.roleMapForModel(model)
+      };
+
+      return inModelContextService;
+    };
+  }) as unknown as InModelContextFirebaseModelServiceFactory<Z, K>;
+
+  return inModelContextFirebaseModelsServiceFactory;
+}
+*/
+//# sourceMappingURL=model.service.js.map

package/src/lib/common/model/model.service.js.map

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

package/src/lib/common/model/permission/index.d.ts

@@ -0,0 +1,4 @@
+export * from './permission';
+export * from './permission.context';
+export * from './permission.service';
+export * from './permission.service.role';

package/src/lib/common/model/permission/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./permission"), exports);
+tslib_1.__exportStar(require("./permission.context"), exports);
+tslib_1.__exportStar(require("./permission.service"), exports);
+tslib_1.__exportStar(require("./permission.service.role"), exports);
+//# sourceMappingURL=index.js.map

package/src/lib/common/model/permission/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../packages/firebase/src/lib/common/model/permission/index.ts"],"names":[],"mappings":";;;AAAA,uDAA6B;AAC7B,+DAAqC;AACrC,+DAAqC;AACrC,oEAA0C"}

package/src/lib/common/model/permission/permission.context.d.ts

@@ -0,0 +1,9 @@
+import { GrantedRole } from '@dereekb/model';
+import { ArrayOrValue } from '@dereekb/util';
+import { FirebaseTransactionContext } from '../../firestore/reference';
+import { FirebaseContextGrantedModelRoles } from './permission';
+export declare type FirebasePermissionContext = FirebaseTransactionContext;
+export declare type FirebasePermissionErrorContextErrorFunction = (firebaseContextGrantedModelRoles: FirebaseContextGrantedModelRoles<FirebasePermissionErrorContext, unknown>, role?: ArrayOrValue<GrantedRole>) => Error;
+export interface FirebasePermissionErrorContext {
+    makePermissionError?: FirebasePermissionErrorContextErrorFunction;
+}

package/src/lib/common/model/permission/permission.context.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=permission.context.js.map

package/src/lib/common/model/permission/permission.context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.context.js","sourceRoot":"","sources":["../../../../../../../../packages/firebase/src/lib/common/model/permission/permission.context.ts"],"names":[],"mappings":""}

package/src/lib/common/model/permission/permission.d.ts

@@ -0,0 +1,11 @@
+import { Maybe } from '@dereekb/util';
+import { GrantedRole, ContextGrantedModelRoles } from '@dereekb/model';
+import { DocumentSnapshot, FirestoreDocument } from '../../firestore';
+import { FirebasePermissionErrorContext } from './permission.context';
+export interface FirebasePermissionServiceModel<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {
+    readonly document: D;
+    readonly snapshot: DocumentSnapshot<T>;
+    readonly exists: boolean;
+    readonly data: Maybe<T>;
+}
+export declare type FirebaseContextGrantedModelRoles<C extends FirebasePermissionErrorContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole> = ContextGrantedModelRoles<FirebasePermissionServiceModel<T, D>, C, R>;

package/src/lib/common/model/permission/permission.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=permission.js.map

package/src/lib/common/model/permission/permission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.js","sourceRoot":"","sources":["../../../../../../../../packages/firebase/src/lib/common/model/permission/permission.ts"],"names":[],"mappings":""}

package/src/lib/common/model/permission/permission.service.d.ts

@@ -0,0 +1,24 @@
+import { FirestoreDocument } from './../../firestore';
+import { AbstractModelPermissionService, GrantedRoleMap, InContextModelPermissionService, InModelContextModelPermissionService, ModelPermissionService } from '@dereekb/model';
+import { Maybe, PromiseOrValue } from '@dereekb/util';
+import { FirebaseModelLoader, InModelContextFirebaseModelLoader } from '../model/model.loader';
+import { FirebaseModelContext } from '../context';
+import { FirebasePermissionServiceModel } from './permission';
+export declare type FirebaseModelPermissionService<C extends FirebaseModelContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends string = string> = ModelPermissionService<C, D, R, FirebasePermissionServiceModel<T, D>>;
+export interface FirebasePermissionServiceInstanceDelegate<C extends FirebaseModelContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends string = string> extends FirebaseModelLoader<C, T, D> {
+    roleMapForModel(output: FirebasePermissionServiceModel<T, D>, context: C, model: D): PromiseOrValue<GrantedRoleMap<R>>;
+}
+/**
+ * Abstract AbstractModelPermissionService implementation for FirebaseModelsPermissionService.
+ */
+export declare class FirebaseModelPermissionServiceInstance<C extends FirebaseModelContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends string = string> extends AbstractModelPermissionService<C, D, R, FirebasePermissionServiceModel<T, D>> implements FirebaseModelPermissionService<C, T, D, R> {
+    readonly delegate: FirebasePermissionServiceInstanceDelegate<C, T, D, R>;
+    constructor(delegate: FirebasePermissionServiceInstanceDelegate<C, T, D, R>);
+    roleMapForModel(output: FirebasePermissionServiceModel<T, D>, context: C, model: D): PromiseOrValue<GrantedRoleMap<R>>;
+    protected outputForModel(document: D): Promise<Maybe<FirebasePermissionServiceModel<T, D>>>;
+    protected getRoleMapForOutput(output: FirebasePermissionServiceModel<T, D>, context: C, model: D): Promise<import("@dereekb/model").ContextGrantedModelRoles<FirebasePermissionServiceModel<T, D>, C, R>>;
+    protected isUsableOutputForRoles(output: FirebasePermissionServiceModel<T, D>): boolean;
+}
+export declare function firebaseModelPermissionService<C extends FirebaseModelContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends string = string>(delegate: FirebasePermissionServiceInstanceDelegate<C, T, D, R>): FirebaseModelPermissionServiceInstance<C, T, D, R>;
+export declare type InContextFirebaseModelPermissionService<C, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends string = string> = InContextModelPermissionService<C, D, R, FirebasePermissionServiceModel<T, D>>;
+export declare type InModelContextFirebaseModelPermissionService<C, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends string = string> = InModelContextModelPermissionService<C, D, R, FirebasePermissionServiceModel<T, D>> & InModelContextFirebaseModelLoader<T, D>;

package/src/lib/common/model/permission/permission.service.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firebaseModelPermissionService = exports.FirebaseModelPermissionServiceInstance = void 0;
+const tslib_1 = require("tslib");
+const model_1 = require("@dereekb/model");
+/**
+ * Abstract AbstractModelPermissionService implementation for FirebaseModelsPermissionService.
+ */
+class FirebaseModelPermissionServiceInstance extends model_1.AbstractModelPermissionService {
+    constructor(delegate) {
+        super(delegate);
+        this.delegate = delegate;
+    }
+    roleMapForModel(output, context, model) {
+        return this.delegate.roleMapForModel(output, context, model);
+    }
+    outputForModel(document) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield document.accessor.get();
+            const data = snapshot.data();
+            const model = { document, snapshot, data, exists: data != null };
+            return model;
+        });
+    }
+    getRoleMapForOutput(output, context, model) {
+        const _super = Object.create(null, {
+            getRoleMapForOutput: { get: () => super.getRoleMapForOutput }
+        });
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (context.adminGetsAllowAllRoles && ((_b = (_a = context.auth) === null || _a === void 0 ? void 0 : _a.isAdmin) === null || _b === void 0 ? void 0 : _b.call(_a))) {
+                return (0, model_1.fullAccessGrantedModelRoles)(context, output);
+            }
+            else {
+                return _super.getRoleMapForOutput.call(this, output, context, model);
+            }
+        });
+    }
+    isUsableOutputForRoles(output) {
+        return output.exists;
+    }
+}
+exports.FirebaseModelPermissionServiceInstance = FirebaseModelPermissionServiceInstance;
+function firebaseModelPermissionService(delegate) {
+    return new FirebaseModelPermissionServiceInstance(delegate);
+}
+exports.firebaseModelPermissionService = firebaseModelPermissionService;
+//# sourceMappingURL=permission.service.js.map

package/src/lib/common/model/permission/permission.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.service.js","sourceRoot":"","sources":["../../../../../../../../packages/firebase/src/lib/common/model/permission/permission.service.ts"],"names":[],"mappings":";;;;AACA,0CAA4M;AAY5M;;GAEG;AACH,MAAa,sCAA4J,SAAQ,sCAA6E;IAC5P,YAAqB,QAA+D;QAClF,KAAK,CAAC,QAAQ,CAAC,CAAC;QADG,aAAQ,GAAR,QAAQ,CAAuD;IAEpF,CAAC;IAED,eAAe,CAAC,MAA4C,EAAE,OAAU,EAAE,KAAQ;QAChF,OAAO,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IAC/D,CAAC;IAEe,cAAc,CAAC,QAAW;;YACxC,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YAC/C,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;YAE7B,MAAM,KAAK,GAAgD,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC;YAC9G,OAAO,KAAK,CAAC;QACf,CAAC;KAAA;IAEwB,mBAAmB,CAAC,MAA4C,EAAE,OAAU,EAAE,KAAQ;;;;;;YAC7G,IAAI,OAAO,CAAC,sBAAsB,KAAI,MAAA,MAAA,OAAO,CAAC,IAAI,0CAAE,OAAO,kDAAI,CAAA,EAAE;gBAC/D,OAAO,IAAA,mCAA2B,EAAC,OAAO,EAAE,MAAM,CAAC,CAAC;aACrD;iBAAM;gBACL,OAAO,OAAM,mBAAmB,YAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE;aAC1D;;KACF;IAEkB,sBAAsB,CAAC,MAA4C;QACpF,OAAO,MAAM,CAAC,MAAM,CAAC;IACvB,CAAC;CACF;AA5BD,wFA4BC;AAED,SAAgB,8BAA8B,CAAsH,QAA+D;IACjO,OAAO,IAAI,sCAAsC,CAAC,QAAQ,CAAC,CAAC;AAC9D,CAAC;AAFD,wEAEC"}

package/src/lib/common/model/permission/permission.service.role.d.ts

@@ -0,0 +1,40 @@
+import { FirestoreDocument } from '../../firestore/accessor/document';
+import { GrantedRole, GrantedRoleMap, GrantedRoleMapReader } from '@dereekb/model';
+import { InModelContextFirebaseModelPermissionService } from './permission.service';
+import { SetIncludesMode, ArrayOrValue } from '@dereekb/util';
+import { FirebasePermissionErrorContext } from './permission.context';
+import { FirebaseContextGrantedModelRoles } from './permission';
+export interface ContextGrantedModelRolesReader<C extends FirebasePermissionErrorContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole> extends GrantedRoleMapReader<R> {
+    readonly roleMap: GrantedRoleMap<R>;
+    readonly contextGrantedModelRoles: FirebaseContextGrantedModelRoles<C, T, D, R>;
+    assertHasRole(role: R): void;
+    assertHasRoles(setIncludes: SetIncludesMode, roles: ArrayOrValue<R>): void;
+    assertContainsRoles(setIncludes: SetIncludesMode, roles: ArrayOrValue<R>): void;
+    throwPermissionError(role?: R): never;
+}
+export declare class ContextGrantedModelRolesReaderInstance<C extends FirebasePermissionErrorContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole> implements ContextGrantedModelRolesReader<C, T, D, R> {
+    readonly contextGrantedModelRoles: FirebaseContextGrantedModelRoles<C, T, D, R>;
+    private _roleReader;
+    constructor(contextGrantedModelRoles: FirebaseContextGrantedModelRoles<C, T, D, R>);
+    get roleMap(): GrantedRoleMap<R>;
+    hasNoAccess(): boolean;
+    hasRole(role: R): boolean;
+    hasRoles(setIncludes: SetIncludesMode, roles: ArrayOrValue<R>): boolean;
+    containsRoles(setIncludes: SetIncludesMode, roles: ArrayOrValue<R>): boolean;
+    assertHasRole(role: R): void;
+    assertHasRoles(setIncludes: SetIncludesMode, roles: ArrayOrValue<R>): void;
+    assertContainsRoles(setIncludes: SetIncludesMode, roles: ArrayOrValue<R>): void;
+    throwPermissionError(role?: ArrayOrValue<R>): never;
+}
+/**
+ * Creates a new ContextGrantedModelRolesReader for the input model.
+ */
+export declare function contextGrantedModelRolesReader<C extends FirebasePermissionErrorContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole>(service: InModelContextFirebaseModelPermissionService<C, T, D, R>): Promise<ContextGrantedModelRolesReader<C, T, D, R>>;
+/**
+ * Creates the default permission error message.
+ *
+ * @param contextGrantedModelRoles
+ * @param role
+ * @returns
+ */
+export declare function contextGrantedModelRolesReaderPermissionErrorMessage(contextGrantedModelRoles: FirebaseContextGrantedModelRoles<FirebasePermissionErrorContext, unknown>, roles?: ArrayOrValue<GrantedRole>): string;

package/src/lib/common/model/permission/permission.service.role.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextGrantedModelRolesReaderPermissionErrorMessage = exports.contextGrantedModelRolesReader = exports.ContextGrantedModelRolesReaderInstance = void 0;
+const model_1 = require("@dereekb/model");
+class ContextGrantedModelRolesReaderInstance {
+    constructor(contextGrantedModelRoles) {
+        this.contextGrantedModelRoles = contextGrantedModelRoles;
+        this._roleReader = (0, model_1.grantedRoleMapReader)(contextGrantedModelRoles.roleMap);
+    }
+    get roleMap() {
+        return this.contextGrantedModelRoles.roleMap;
+    }
+    hasNoAccess() {
+        return this._roleReader.hasNoAccess();
+    }
+    hasRole(role) {
+        return this._roleReader.hasRole(role);
+    }
+    hasRoles(setIncludes, roles) {
+        return this._roleReader.hasRoles(setIncludes, roles);
+    }
+    containsRoles(setIncludes, roles) {
+        return this._roleReader.containsRoles(setIncludes, roles);
+    }
+    assertHasRole(role) {
+        if (!this.hasRole(role)) {
+            this.throwPermissionError(role);
+        }
+    }
+    assertHasRoles(setIncludes, roles) {
+        if (!this.hasRoles(setIncludes, roles)) {
+            this.throwPermissionError(roles);
+        }
+    }
+    assertContainsRoles(setIncludes, roles) {
+        if (!this.containsRoles(setIncludes, roles)) {
+            this.throwPermissionError(roles);
+        }
+    }
+    throwPermissionError(role) {
+        var _a, _b, _c;
+        const error = (_c = (_b = (_a = this.contextGrantedModelRoles.context).makePermissionError) === null || _b === void 0 ? void 0 : _b.call(_a, this.contextGrantedModelRoles, role)) !== null && _c !== void 0 ? _c : new Error(contextGrantedModelRolesReaderPermissionErrorMessage(this.contextGrantedModelRoles, role));
+        throw error;
+    }
+}
+exports.ContextGrantedModelRolesReaderInstance = ContextGrantedModelRolesReaderInstance;
+/**
+ * Creates a new ContextGrantedModelRolesReader for the input model.
+ */
+function contextGrantedModelRolesReader(service) {
+    return service.roleMap().then((x) => new ContextGrantedModelRolesReaderInstance(x));
+}
+exports.contextGrantedModelRolesReader = contextGrantedModelRolesReader;
+/**
+ * Creates the default permission error message.
+ *
+ * @param contextGrantedModelRoles
+ * @param role
+ * @returns
+ */
+function contextGrantedModelRolesReaderPermissionErrorMessage(contextGrantedModelRoles, roles) {
+    var _a, _b;
+    let message = `Permissions Error ("${(_a = contextGrantedModelRoles.data) === null || _a === void 0 ? void 0 : _a.document.modelType}":"${(_b = contextGrantedModelRoles.data) === null || _b === void 0 ? void 0 : _b.document.id}")`;
+    if (roles && (roles === null || roles === void 0 ? void 0 : roles.length)) {
+        message = `${message}: required role(s) "${roles}"`;
+    }
+    return message;
+}
+exports.contextGrantedModelRolesReaderPermissionErrorMessage = contextGrantedModelRolesReaderPermissionErrorMessage;
+//# sourceMappingURL=permission.service.role.js.map

package/src/lib/common/model/permission/permission.service.role.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.service.role.js","sourceRoot":"","sources":["../../../../../../../../packages/firebase/src/lib/common/model/permission/permission.service.role.ts"],"names":[],"mappings":";;;AACA,0CAAyG;AAezG,MAAa,sCAAsC;IAGjD,YAAqB,wBAAsE;QAAtE,6BAAwB,GAAxB,wBAAwB,CAA8C;QACzF,IAAI,CAAC,WAAW,GAAG,IAAA,4BAAoB,EAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;IAC5E,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC;IAC/C,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;IACxC,CAAC;IAED,OAAO,CAAC,IAAO;QACb,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAED,QAAQ,CAAC,WAA4B,EAAE,KAAsB;QAC3D,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IACvD,CAAC;IAED,aAAa,CAAC,WAA4B,EAAE,KAAsB;QAChE,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IAC5D,CAAC;IAED,aAAa,CAAC,IAAO;QACnB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACvB,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;SACjC;IACH,CAAC;IAED,cAAc,CAAC,WAA4B,EAAE,KAAsB;QACjE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,EAAE;YACtC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;SAClC;IACH,CAAC;IAED,mBAAmB,CAAC,WAA4B,EAAE,KAAsB;QACtE,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,KAAK,CAAC,EAAE;YAC3C,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;SAClC;IACH,CAAC;IAED,oBAAoB,CAAC,IAAsB;;QACzC,MAAM,KAAK,GAAG,MAAA,MAAA,MAAA,IAAI,CAAC,wBAAwB,CAAC,OAAO,EAAC,mBAAmB,mDAAG,IAAI,CAAC,wBAAwB,EAAE,IAAI,CAAC,mCAAI,IAAI,KAAK,CAAC,oDAAoD,CAAC,IAAI,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC,CAAC;QACvN,MAAM,KAAK,CAAC;IACd,CAAC;CACF;AAjDD,wFAiDC;AAED;;GAEG;AACH,SAAgB,8BAA8B,CAA0I,OAAiE;IACvP,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,sCAAsC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtF,CAAC;AAFD,wEAEC;AAED;;;;;;GAMG;AACH,SAAgB,oDAAoD,CAAC,wBAAmG,EAAE,KAAiC;;IACzM,IAAI,OAAO,GAAG,uBAAuB,MAAA,wBAAwB,CAAC,IAAI,0CAAE,QAAQ,CAAC,SAAS,MAAM,MAAA,wBAAwB,CAAC,IAAI,0CAAE,QAAQ,CAAC,EAAE,IAAI,CAAC;IAE3I,IAAI,KAAK,KAAI,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,MAAM,CAAA,EAAE;QAC1B,OAAO,GAAG,GAAG,OAAO,uBAAuB,KAAK,GAAG,CAAC;KACrD;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AARD,oHAQC"}

package/test/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+# [6.0.0](https://github.com/dereekb/dbx-components/compare/v5.3.0-dev...v6.0.0) (2022-06-03)
+
+
+### Features
+
+* added ContextGrantedModelRolesReader ([6fba1cc](https://github.com/dereekb/dbx-components/commit/6fba1cc637beeff55523df599eb88391352f9f58))
+* added firebaseModelsService ([7432e55](https://github.com/dereekb/dbx-components/commit/7432e55111cec66a239856ecb2db6adfc9e9780d))
+* added loadDocumentForKey to LimitedFirestoreDocumentAccessor ([96958b8](https://github.com/dereekb/dbx-components/commit/96958b89df62dc38136ac2dfcd2ce7c139b6099e))
+* added modelType to FirestoreDocument ([deecb5d](https://github.com/dereekb/dbx-components/commit/deecb5df415ed9d99412c336ba65f4da572bbe44))
+* added OnCallDeleteModel ([358189d](https://github.com/dereekb/dbx-components/commit/358189d6db6ef7d8db93d6dd881d29cc724dd083))
+* added orderByDocumentId, startAtValue, endAtValue constraints ([c846fee](https://github.com/dereekb/dbx-components/commit/c846feef6c26a3818bb006a807b6e931b7b14eaf))
+
+
+### BREAKING CHANGES
+
+* model type is now required on FirestoreDocument models
+
+
+
+# [5.3.0](https://github.com/dereekb/dbx-components/compare/v5.2.1-dev...v5.3.0) (2022-05-30)
+
+
+
+## [5.2.1](https://github.com/dereekb/dbx-components/compare/v5.2.0-dev...v5.2.1) (2022-05-29)
+
+
+
 # [5.2.0](https://github.com/dereekb/dbx-components/compare/v5.1.0-dev...v5.2.0) (2022-05-29)
 
 

package/test/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@dereekb/firebase/test",
-  "version": "5.2.0",
+  "version": "6.0.0",
   "main": "./src/index.js",
   "typings": "./src/index.d.ts",
   "dependencies": {},
   "peerDependencies": {
-    "@dereekb/util/test": "5.2.0",
-    "@dereekb/util": "5.2.0",
+    "@dereekb/util/test": "6.0.0",
+    "@dereekb/util": "6.0.0",
     "make-error": "^1.3.0",
     "extra-set": "^2.2.11",
-    "@dereekb/firebase": "5.2.0",
+    "@dereekb/firebase": "6.0.0",
     "rxjs": "^7.0.0",
     "rxfire": "^6.0.3",
     "firebase": "^9.8.0",
-    "@dereekb/rxjs": "5.2.0",
+    "@dereekb/rxjs": "6.0.0",
     "ms": "^3.0.0-canary.1",
-    "@dereekb/date": "5.2.0",
+    "@dereekb/date": "6.0.0",
     "class-transformer": "^0.5.1",
     "date-fns": "^2.28.0",
     "class-validator": "^0.13.2",
     "date-fns-tz": "^1.3.0",
     "rrule": "git+https://git@github.com/dereekb/rrule.git#17adf5708d6567b4d01a3a8afd106261421ea492",
-    "@dereekb/model": "5.2.0",
+    "@dereekb/model": "6.0.0",
     "tslib": "^2.0.0"
   }
 }

package/test/src/lib/common/firestore.d.ts

@@ -11,9 +11,9 @@ export interface TestingFirestoreAccessorDriver extends FirestoreAccessorDriver
      * Initializes fuzzed path names for the input collections. Returns the result of getFuzzedCollectionsNameMap().
      *
      * This initialization step is useful for the client, where the rules file needs to be updated to reflect the collection names properly in order to ensure rules are correct.
-     * @param collectionPaths
+     * @param collectionNames
      */
-    initWithCollectionNames(collectionPaths: string[]): Map<string, string>;
+    initWithCollectionNames(collectionNames: string[]): Map<string, string>;
 }
 export declare function makeTestingFirestoreAccesorDriver(driver: FirestoreAccessorDriver): TestingFirestoreAccessorDriver;
 /**
@@ -34,5 +34,5 @@ export interface TestingFirestoreContextExtension {
     drivers: TestingFirestoreDrivers;
 }
 export declare type TestFirestoreContext<C = FirestoreContext> = C & TestingFirestoreContextExtension;
-export declare type ClearTestFirestoreCollectionFunction = (collectionName: string, realCollectionPath: string) => Promise<void>;
+export declare type ClearTestFirestoreCollectionFunction = (collectionName: string, realCollectionName: string) => Promise<void>;
 export declare function clearTestFirestoreContextCollections(context: TestFirestoreContext, clearCollection: ClearTestFirestoreCollectionFunction): Promise<void>;

package/test/src/lib/common/firestore.js

@@ -30,8 +30,8 @@ function makeTestingFirestoreAccesorDriver(driver) {
         const fuzzedPath = fuzzedPathForPath(collectionId);
         return collectionGroup(f, fuzzedPath);
     };
-    const initWithCollectionNames = (collectionPaths) => {
-        collectionPaths.forEach((x) => fuzzedPathForPath(x));
+    const initWithCollectionNames = (collectionNames) => {
+        collectionNames.forEach((x) => fuzzedPathForPath(x));
         return fuzzedMap;
     };
     const injectedDriver = Object.assign(Object.assign({}, driver), { collection: fuzzedCollection, collectionGroup: fuzzedCollectionGroup, subcollection: fuzzedSubcollection, getFuzzedCollectionsNameMap: () => fuzzedMap, initWithCollectionNames });

package/test/src/lib/common/firestore.mock.item.d.ts

@@ -1,5 +1,8 @@
 import { Maybe } from '@dereekb/util';
-import { CollectionReference, FirestoreCollection, FirestoreContext, AbstractFirestoreDocument, SingleItemFirestoreCollection, FirestoreCollectionWithParent, AbstractFirestoreDocumentWithParent, ExpectedFirestoreModelData, FirestoreModelData, CollectionGroup, FirestoreCollectionGroup } from '@dereekb/firebase';
+import { CollectionReference, FirestoreCollection, FirestoreContext, AbstractFirestoreDocument, SingleItemFirestoreCollection, FirestoreCollectionWithParent, AbstractFirestoreDocumentWithParent, ExpectedFirestoreModelData, FirestoreModelData, CollectionGroup, FirestoreCollectionGroup, FirestoreModelIdentity } from '@dereekb/firebase';
+import { GrantedReadRole } from '@dereekb/model';
+export declare type MockItemTypes = typeof mockItemIdentity | typeof mockItemPrivateIdentity | typeof mockItemSubItemIdentity | typeof mockItemDeepSubItemIdentity;
+export declare const mockItemIdentity: FirestoreModelIdentity<"mockItem">;
 /**
  * Converted data for a test item in our firestore collection.
  */
@@ -10,7 +13,9 @@ export interface MockItem {
      */
     test: boolean;
 }
+export declare type MockItemRoles = GrantedReadRole | 'admin';
 export declare class MockItemDocument extends AbstractFirestoreDocument<MockItem, MockItemDocument> {
+    get modelIdentity(): FirestoreModelIdentity<"mockItem">;
 }
 /**
  * MockItem as it is stored into the database.
@@ -23,10 +28,6 @@ export declare type MockItemData = FirestoreModelData<MockItem, {
      */
     test?: Maybe<boolean>;
 }>;
-/**
- * Firestore collection path name.
- */
-export declare const mockItemCollectionPath = "test";
 /**
  * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
  */
@@ -45,6 +46,7 @@ export declare const mockItemConverter: import("@dereekb/firebase").SnapshotConv
 export declare function mockItemCollectionReference(context: FirestoreContext): CollectionReference<MockItem>;
 export declare type MockItemFirestoreCollection = FirestoreCollection<MockItem, MockItemDocument>;
 export declare function mockItemFirestoreCollection(firestoreContext: FirestoreContext): MockItemFirestoreCollection;
+export declare const mockItemPrivateIdentity: FirestoreModelIdentity<"mockItemPrivate">;
 /**
  * Private data for each MockItem.
  *
@@ -54,16 +56,18 @@ export interface MockItemPrivate {
     comments?: Maybe<string>;
     createdAt: Date;
 }
+export declare type MockItemPrivateRoles = GrantedReadRole | 'admin';
 /**
  * FirestoreDocument for MockItem
  */
 export declare class MockItemPrivateDocument extends AbstractFirestoreDocument<MockItemPrivate, MockItemPrivateDocument> {
+    get modelIdentity(): FirestoreModelIdentity<"mockItemPrivate">;
 }
 export declare type MockItemPrivateData = FirestoreModelData<MockItemPrivate, {}>;
 /**
  * Firestore collection path name.
  */
-export declare const mockItemPrivateCollectionPath = "private";
+export declare const mockItemPrivateCollectionName = "mockitemprivate";
 export declare const mockItemPrivateIdentifier = "0";
 /**
  * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
@@ -85,6 +89,10 @@ export declare function mockItemPrivateCollectionReferenceFactory(context: Fires
 export declare type MockItemPrivateFirestoreCollection = SingleItemFirestoreCollection<MockItemPrivate, MockItem, MockItemPrivateDocument>;
 export declare type MockItemPrivateFirestoreCollectionFactory = (parent: MockItemDocument) => MockItemPrivateFirestoreCollection;
 export declare function mockItemPrivateFirestoreCollection(firestoreContext: FirestoreContext): MockItemPrivateFirestoreCollectionFactory;
+export declare function mockItemPrivateCollectionReference(context: FirestoreContext): CollectionGroup<MockItemPrivate>;
+export declare type MockItemPrivateFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemPrivate, MockItemPrivateDocument>;
+export declare function mockItemPrivateFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemPrivateFirestoreCollectionGroup;
+export declare const mockItemSubItemIdentity: FirestoreModelIdentity<"mockItemSub">;
 /**
  * Data for a sub item in our firestore collection.
  *
@@ -93,16 +101,14 @@ export declare function mockItemPrivateFirestoreCollection(firestoreContext: Fir
 export interface MockItemSubItem {
     value?: Maybe<number>;
 }
+export declare type MockItemSubItemRoles = GrantedReadRole | 'admin';
 /**
  * FirestoreDocument for MockItem
  */
 export declare class MockItemSubItemDocument extends AbstractFirestoreDocumentWithParent<MockItem, MockItemSubItem, MockItemSubItemDocument> {
+    get modelIdentity(): FirestoreModelIdentity;
 }
 export declare type MockItemSubItemData = ExpectedFirestoreModelData<MockItemSubItem>;
-/**
- * Firestore collection path name.
- */
-export declare const mockItemSubItemCollectionPath = "sub";
 /**
  * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
  */
@@ -114,10 +120,31 @@ export declare function mockItemSubItemFirestoreCollection(firestoreContext: Fir
 export declare function mockItemSubItemCollectionReference(context: FirestoreContext): CollectionGroup<MockItemSubItem>;
 export declare type MockItemSubItemFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemSubItem, MockItemSubItemDocument>;
 export declare function mockItemSubItemFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemSubItemFirestoreCollectionGroup;
-export declare abstract class MockItemCollections {
-    abstract readonly mockItem: MockItemFirestoreCollection;
-    abstract readonly mockItemPrivate: MockItemPrivateFirestoreCollectionFactory;
-    abstract readonly mockItemSubItem: MockItemSubItemFirestoreCollectionFactory;
-    abstract readonly mockItemSubItemGroup: MockItemSubItemFirestoreCollectionGroup;
+export declare const mockItemDeepSubItemIdentity: FirestoreModelIdentity<"mockItemDeepSub">;
+/**
+ * Data for a sub item in our firestore collection.
+ *
+ * There may be an unlimited number of MockItemDeepSubItems for a MockSubItem.
+ */
+export interface MockItemDeepSubItem {
+    value?: Maybe<number>;
+}
+export declare type MockItemDeepSubItemRoles = GrantedReadRole | 'admin';
+/**
+ * FirestoreDocument for MockSubItem
+ */
+export declare class MockItemDeepSubItemDocument extends AbstractFirestoreDocumentWithParent<MockItemSubItem, MockItemDeepSubItem, MockItemDeepSubItemDocument> {
+    get modelIdentity(): FirestoreModelIdentity<"mockItemDeepSub">;
 }
-export declare function makeMockItemCollections(firestoreContext: FirestoreContext): MockItemCollections;
+export declare type MockItemDeepSubItemData = ExpectedFirestoreModelData<MockItemDeepSubItem>;
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+export declare const mockItemDeepSubItemConverter: import("@dereekb/firebase").SnapshotConverterFunctions<MockItemDeepSubItem, import("@dereekb/util").ReplaceType<MockItemDeepSubItem, object, any>>;
+export declare function mockItemDeepSubItemCollectionReferenceFactory(context: FirestoreContext): (parent: MockItemSubItemDocument) => CollectionReference<MockItemDeepSubItem>;
+export declare type MockItemDeepSubItemFirestoreCollection = FirestoreCollectionWithParent<MockItemDeepSubItem, MockItemSubItem, MockItemDeepSubItemDocument, MockItemSubItemDocument>;
+export declare type MockItemDeepSubItemFirestoreCollectionFactory = (parent: MockItemSubItemDocument) => MockItemDeepSubItemFirestoreCollection;
+export declare function mockItemDeepSubItemFirestoreCollection(firestoreContext: FirestoreContext): MockItemDeepSubItemFirestoreCollectionFactory;
+export declare function mockItemDeepSubItemCollectionReference(context: FirestoreContext): CollectionGroup<MockItemDeepSubItem>;
+export declare type MockItemDeepSubItemFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemDeepSubItem, MockItemDeepSubItemDocument>;
+export declare function mockItemDeepSubItemFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemDeepSubItemFirestoreCollectionGroup;

package/test/src/lib/common/firestore.mock.item.fixture.d.ts

@@ -4,12 +4,14 @@ import { MockItemFirestoreCollection, MockItem } from './firestore.mock.item';
 import { TestFirestoreContextFixture } from './firestore.mock';
 export declare class MockItemCollectionFixtureInstance {
     readonly fixture: MockItemCollectionFixture;
-    readonly collections: import("./firestore.mock.item").MockItemCollections;
+    readonly collections: import("./firestore.mock.item.service").MockItemCollections;
     get collection(): CollectionReference<MockItem>;
     get firestoreCollection(): MockItemFirestoreCollection;
     get mockItemPrivateCollection(): import("./firestore.mock.item").MockItemPrivateFirestoreCollectionFactory;
     get mockItemSubItemCollection(): import("./firestore.mock.item").MockItemSubItemFirestoreCollectionFactory;
     get mockItemSubItemCollectionGroup(): import("./firestore.mock.item").MockItemSubItemFirestoreCollectionGroup;
+    get mockItemDeepSubItemCollection(): import("./firestore.mock.item").MockItemDeepSubItemFirestoreCollectionFactory;
+    get mockItemDeepSubItemCollectionGroup(): import("./firestore.mock.item").MockItemDeepSubItemFirestoreCollectionGroup;
     constructor(fixture: MockItemCollectionFixture);
 }
 /**