@graph-knowledge/api 0.1.3 → 0.1.5

package/README.md

@@ -101,6 +101,7 @@ new GraphKnowledgeAPI(config: ApiConfig)
 | `nodes` | `INodeOperations` | Node CRUD operations |
 | `elements` | `IElementOperations` | Element CRUD operations |
 | `batch` | `IBatchOperations` | Batch element operations |
+| `templates` | `ITemplateOperations` | Template operations (list, get, clone) |
 | `authClient` | `IAuthClient` | Authentication client |
 
 ### Document Operations
@@ -194,6 +195,17 @@ await api.elements.create(documentId, nodeId, {
     textAlign: "center"
 });
 
+// Create multi-line text (use \n for line breaks)
+await api.elements.create(documentId, nodeId, {
+    type: "text",
+    x: 100,
+    y: 200,
+    text: "Line 1\nLine 2\nLine 3",
+    fontSize: 18,
+    lineHeight: 1.4  // Optional: adjust line spacing (default: 1.2)
+});
+// Note: height is auto-calculated based on the number of lines and lineHeight
+
 // Create a connector
 await api.elements.create(documentId, nodeId, {
     type: "connector",
@@ -232,6 +244,35 @@ await api.elements.update(documentId, nodeId, elementId, {
 await api.elements.delete(documentId, nodeId, elementId);
 ```
 
+### Template Operations
+
+Templates are pre-made documents that can be cloned by premium users:
+
+```typescript
+// List all available templates
+const templates = await api.templates.list();
+console.log(templates);
+// [{ id: "template-1", title: "UML Class Diagram", isTemplate: true, ... }]
+
+// Get a specific template with all its nodes and elements
+const template = await api.templates.get("template-1");
+
+// Clone a template (creates a new document) - requires premium
+const myDoc = await api.templates.clone("template-1");
+// Creates "Copy of UML Class Diagram" document
+
+// Clone with custom title
+const myDoc2 = await api.templates.clone("template-1", "My Project Diagram");
+// Creates "My Project Diagram" document
+
+// The cloned document:
+// - Has a new unique ID
+// - Is owned by the current user
+// - Has isTemplate: false
+// - Has clonedFromTemplateId pointing to the source template
+// - Contains copies of all nodes and elements with new IDs
+```
+
 ### Batch Operations
 
 For efficient bulk operations (ideal for AI agents and automation):
@@ -263,7 +304,7 @@ await api.batch.deleteElements(documentId, nodeId, [
 | Type | Description |
 |------|-------------|
 | `rectangle` | Rectangle shape with fill, stroke, corner radius |
-| `text` | Text element with font customization |
+| `text` | Text element with font customization (supports multi-line with `\n`) |
 | `connector` | Line connecting two elements |
 | `uml-class` | UML class diagram element |
 | `uml-interface` | UML interface element |
@@ -368,6 +409,7 @@ GraphKnowledgeAPI (Composition Root)
     ├── NodeOperations : INodeOperations
     ├── ElementOperations : IElementOperations
     ├── BatchOperations : IBatchOperations
+    ├── TemplateOperations : ITemplateOperations
     └── ElementValidatorRegistry : IElementValidatorRegistry
             ├── RectangleValidator
             ├── TextValidator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graph-knowledge/api",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Headless Document API for Graph Knowledge - programmatic access to documents, nodes, and elements",
   "license": "MIT",
   "author": "Graph Knowledge Team",

package/src/index.d.ts

@@ -6,6 +6,7 @@ export type { IDocumentOperations } from "./lib/interfaces/document-operations.i
 export type { INodeOperations } from "./lib/interfaces/node-operations.interface";
 export type { IElementOperations } from "./lib/interfaces/element-operations.interface";
 export type { IBatchOperations, BatchUpdateElementInput } from "./lib/interfaces/batch-operations.interface";
+export type { ITemplateOperations } from "./lib/interfaces/template-operations.interface";
 export type { IElementTypeValidator, IElementValidatorRegistry } from "./lib/interfaces/element-validator.interface";
 export type { CreateDocumentInput, UpdateDocumentInput, DocumentResult, CreateNodeInput, UpdateNodeInput, NodeResult } from "./lib/types/api-types";
 export type { BaseElementInput, RectangleInput, TextInput, ConnectorInput, ConnectorAnchor, LineStyle, MarkerType, UmlClassInput, UmlInterfaceInput, UmlComponentInput, UmlPackageInput, UmlArtifactInput, UmlNoteInput, CustomShapeInput, AnyElementInput, UpdateElementInput } from "./lib/types/element-input-types";

package/src/lib/clients/firebase-auth-client.d.ts

@@ -21,4 +21,6 @@ export declare class FirebaseAuthClient implements IAuthClient {
     requireAuth(): string;
     isPremium(): Promise<boolean>;
     requirePremium(): Promise<void>;
+    isAdmin(): Promise<boolean>;
+    requireAdmin(): Promise<void>;
 }

package/src/lib/clients/firebase-auth-client.js

@@ -76,5 +76,25 @@ class FirebaseAuthClient {
             throw new api_errors_1.PermissionError("Premium subscription required");
         }
     }
+    async isAdmin() {
+        if (!this._currentUser) {
+            return false;
+        }
+        // Read admin status from user profile in Firestore
+        const userDoc = (0, firestore_1.doc)(this.firestore, `users/${this._currentUser.uid}`);
+        const snapshot = await (0, firestore_1.getDoc)(userDoc);
+        if (!snapshot.exists()) {
+            return false;
+        }
+        const profile = snapshot.data();
+        return profile?.["isAdmin"] === true;
+    }
+    async requireAdmin() {
+        this.requireAuth();
+        const admin = await this.isAdmin();
+        if (!admin) {
+            throw new api_errors_1.PermissionError("Admin access required");
+        }
+    }
 }
 exports.FirebaseAuthClient = FirebaseAuthClient;

package/src/lib/clients/firebase-firestore-client.d.ts

@@ -15,7 +15,7 @@ export declare class FirebaseFirestoreClient implements IFirestoreClient {
     getCollection<T>(path: string): Promise<(T & {
         id: string;
     })[]>;
-    queryCollection<T>(path: string, field: string, value: string): Promise<(T & {
+    queryCollection<T>(path: string, field: string, value: string | number | boolean | null): Promise<(T & {
         id: string;
     })[]>;
     batch(): IBatchWriter;

package/src/lib/graph-knowledge-api.d.ts

@@ -4,6 +4,7 @@ import { IDocumentOperations } from "./interfaces/document-operations.interface"
 import { INodeOperations } from "./interfaces/node-operations.interface";
 import { IElementOperations } from "./interfaces/element-operations.interface";
 import { IBatchOperations } from "./interfaces/batch-operations.interface";
+import { ITemplateOperations } from "./interfaces/template-operations.interface";
 /**
  * Main entry point for the Graph Knowledge Headless API.
  *
@@ -48,6 +49,7 @@ export declare class GraphKnowledgeAPI {
     private readonly _nodes;
     private readonly _elements;
     private readonly _batch;
+    private readonly _templates;
     /**
      * Creates a new GraphKnowledgeAPI instance.
      * @param config Configuration including Firebase credentials
@@ -73,6 +75,12 @@ export declare class GraphKnowledgeAPI {
      * Batch element operations (createElements, updateElements, deleteElements).
      */
     get batch(): IBatchOperations;
+    /**
+     * Template operations (list, get, clone, publish, unpublish).
+     * Templates are documents that can be cloned by premium users.
+     * Admins can publish/unpublish templates to control visibility.
+     */
+    get templates(): ITemplateOperations;
     /**
      * Signs in with email and password.
      * @param email User email

package/src/lib/graph-knowledge-api.js

@@ -10,6 +10,7 @@ const document_operations_1 = require("./operations/document-operations");
 const node_operations_1 = require("./operations/node-operations");
 const element_operations_1 = require("./operations/element-operations");
 const batch_operations_1 = require("./operations/batch-operations");
+const template_operations_1 = require("./operations/template-operations");
 const document_validator_1 = require("./validators/document-validator");
 const node_validator_1 = require("./validators/node-validator");
 const element_validator_registry_1 = require("./validators/element-validator-registry");
@@ -57,6 +58,7 @@ class GraphKnowledgeAPI {
     _nodes;
     _elements;
     _batch;
+    _templates;
     /**
      * Creates a new GraphKnowledgeAPI instance.
      * @param config Configuration including Firebase credentials
@@ -78,6 +80,7 @@ class GraphKnowledgeAPI {
         this._nodes = new node_operations_1.NodeOperations(firestoreClient, this._authClient, nodeValidator);
         this._elements = new element_operations_1.ElementOperations(firestoreClient, this._authClient, elementValidatorRegistry);
         this._batch = new batch_operations_1.BatchOperations(firestoreClient, this._authClient, elementValidatorRegistry);
+        this._templates = new template_operations_1.TemplateOperations(firestoreClient, this._authClient);
     }
     /**
      * Authentication client for sign-in/sign-out operations.
@@ -109,6 +112,14 @@ class GraphKnowledgeAPI {
     get batch() {
         return this._batch;
     }
+    /**
+     * Template operations (list, get, clone, publish, unpublish).
+     * Templates are documents that can be cloned by premium users.
+     * Admins can publish/unpublish templates to control visibility.
+     */
+    get templates() {
+        return this._templates;
+    }
     // =========================================================================
     // Convenience methods delegating to authClient
     // =========================================================================

package/src/lib/interfaces/auth-client.interface.d.ts

@@ -32,4 +32,15 @@ export interface IAuthClient {
      * @throws PermissionError if not premium
      */
     requirePremium(): Promise<void>;
+    /**
+     * Checks if the current user has admin status.
+     * @returns Promise resolving to true if user is admin
+     */
+    isAdmin(): Promise<boolean>;
+    /**
+     * Requires the current user to have admin status.
+     * @throws AuthenticationError if not authenticated
+     * @throws PermissionError if not admin
+     */
+    requireAdmin(): Promise<void>;
 }

package/src/lib/interfaces/firestore-client.interface.d.ts

@@ -51,8 +51,9 @@ export interface IFirestoreClient {
     })[]>;
     /**
      * Queries documents in a collection where a field equals a value.
+     * Supports string, number, boolean, and null values.
      */
-    queryCollection<T>(path: string, field: string, value: string): Promise<(T & {
+    queryCollection<T>(path: string, field: string, value: string | number | boolean | null): Promise<(T & {
         id: string;
     })[]>;
     /**

package/src/lib/interfaces/template-operations.interface.d.ts

@@ -0,0 +1,55 @@
+import { DocumentResult } from "../types/api-types";
+/**
+ * Interface for template operations.
+ *
+ * Templates are documents with `isTemplate: true` that can be cloned
+ * by premium users to create new documents.
+ */
+export interface ITemplateOperations {
+    /**
+     * Lists all published templates available to users.
+     * @returns Array of published template documents (shallow, without nodes)
+     * @throws AuthenticationError if not authenticated
+     */
+    list(): Promise<DocumentResult[]>;
+    /**
+     * Gets a single template by ID, including all its nodes.
+     * @param templateId The template document ID
+     * @returns The template with all nodes
+     * @throws AuthenticationError if not authenticated
+     * @throws NotFoundError if template doesn't exist
+     */
+    get(templateId: string): Promise<DocumentResult>;
+    /**
+     * Clones a template into a new document owned by the current user.
+     * Requires premium access.
+     *
+     * @param templateId The template to clone
+     * @param title Optional custom title (defaults to "Copy of {template.title}")
+     * @returns The newly created document
+     * @throws AuthenticationError if not authenticated
+     * @throws PermissionError if not premium user
+     * @throws NotFoundError if template doesn't exist
+     */
+    clone(templateId: string, title?: string): Promise<DocumentResult>;
+    /**
+     * Publishes a template, making it visible to all users.
+     * Requires admin access.
+     *
+     * @param templateId The template ID to publish
+     * @throws AuthenticationError if not authenticated
+     * @throws PermissionError if not admin
+     * @throws NotFoundError if template doesn't exist
+     */
+    publish(templateId: string): Promise<void>;
+    /**
+     * Unpublishes a template, hiding it from regular users.
+     * Requires admin access.
+     *
+     * @param templateId The template ID to unpublish
+     * @throws AuthenticationError if not authenticated
+     * @throws PermissionError if not admin
+     * @throws NotFoundError if template doesn't exist
+     */
+    unpublish(templateId: string): Promise<void>;
+}

package/src/lib/interfaces/template-operations.interface.js

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

package/src/lib/models/document.model.d.ts

@@ -42,6 +42,21 @@ export interface Document {
     nodes?: GraphNode[];
     rootNodeId?: string;
     isPremiumContent?: boolean;
+    /**
+     * Template flag - only admins can set this to true.
+     * Templates are visible to all authenticated users.
+     */
+    isTemplate?: boolean;
+    /**
+     * Whether the template is published and visible to users (templates only).
+     * Unpublished templates are only visible to admins.
+     */
+    isPublished?: boolean;
+    /**
+     * Source template ID if this document was cloned from a template.
+     * Provides audit trail for template usage.
+     */
+    clonedFromTemplateId?: string;
 }
 export interface GraphNode {
     id: string;

package/src/lib/operations/template-operations.d.ts

@@ -0,0 +1,30 @@
+import { ITemplateOperations } from "../interfaces/template-operations.interface";
+import { IFirestoreClient } from "../interfaces/firestore-client.interface";
+import { IAuthClient } from "../interfaces/auth-client.interface";
+import { DocumentResult } from "../types/api-types";
+/**
+ * Implementation of template operations.
+ *
+ * Templates are documents with `isTemplate: true` that can be cloned
+ * by premium users to create new documents.
+ */
+export declare class TemplateOperations implements ITemplateOperations {
+    private readonly firestore;
+    private readonly auth;
+    constructor(firestore: IFirestoreClient, auth: IAuthClient);
+    list(): Promise<DocumentResult[]>;
+    get(templateId: string): Promise<DocumentResult>;
+    clone(templateId: string, title?: string): Promise<DocumentResult>;
+    publish(templateId: string): Promise<void>;
+    unpublish(templateId: string): Promise<void>;
+    /**
+     * Clones a node with updated IDs and references.
+     * Note: Firestore doesn't allow undefined values, so we conditionally include optional fields.
+     */
+    private _cloneNode;
+    /**
+     * Clones an element with updated IDs and references.
+     * Note: Firestore doesn't allow undefined values, so we conditionally include optional fields.
+     */
+    private _cloneElement;
+}

package/src/lib/operations/template-operations.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateOperations = void 0;
+const models_1 = require("../models");
+const uuid_1 = require("../utils/uuid");
+const api_errors_1 = require("../errors/api-errors");
+// Default canvas dimensions
+const DEFAULT_CANVAS_WIDTH = 1920;
+const DEFAULT_CANVAS_HEIGHT = 1080;
+/**
+ * Implementation of template operations.
+ *
+ * Templates are documents with `isTemplate: true` that can be cloned
+ * by premium users to create new documents.
+ */
+class TemplateOperations {
+    firestore;
+    auth;
+    constructor(firestore, auth) {
+        this.firestore = firestore;
+        this.auth = auth;
+    }
+    async list() {
+        this.auth.requireAuth();
+        // Check if user is admin (admins can see all templates including unpublished)
+        const isAdmin = await this.auth.isAdmin();
+        // Query templates where isTemplate == true
+        const documents = await this.firestore.queryCollection("documents", "isTemplate", true);
+        // Filter based on user role:
+        // - Admins can see all templates (published and unpublished)
+        // - Regular users can only see published templates
+        const templates = isAdmin
+            ? documents
+            : documents.filter((doc) => {
+                const d = doc;
+                return d.isPublished === true;
+            });
+        // Return shallow documents without nodes
+        return templates.map((doc) => ({
+            ...doc,
+            nodes: []
+        }));
+    }
+    async get(templateId) {
+        this.auth.requireAuth();
+        const docData = await this.firestore.getDocument(`documents/${templateId}`);
+        if (!docData) {
+            throw new api_errors_1.NotFoundError(`Template ${templateId} not found`);
+        }
+        const docWithFlags = docData;
+        // Verify it's actually a template
+        if (!docWithFlags.isTemplate) {
+            throw new api_errors_1.NotFoundError(`Document ${templateId} is not a template`);
+        }
+        // Check visibility: unpublished templates are only visible to admins
+        if (!docWithFlags.isPublished) {
+            const isAdmin = await this.auth.isAdmin();
+            if (!isAdmin) {
+                throw new api_errors_1.NotFoundError(`Template ${templateId} not found`);
+            }
+        }
+        const nodes = await this.firestore.getCollection(`documents/${templateId}/nodes`);
+        return {
+            ...docData,
+            nodes
+        };
+    }
+    async clone(templateId, title) {
+        const userId = this.auth.requireAuth();
+        // Require premium access for cloning
+        await this.auth.requirePremium();
+        // Get the template with all its nodes
+        const template = await this.get(templateId);
+        // Build ID mapping for nodes and elements
+        const idMapping = new Map();
+        const nodes = template.nodes || [];
+        nodes.forEach((node) => {
+            idMapping.set(node.id, (0, uuid_1.generateUuid)());
+            node.elements.forEach((element) => {
+                idMapping.set(element.id, (0, uuid_1.generateUuid)());
+            });
+        });
+        // Determine new root node ID - fail fast if template's root node is missing
+        if (template.rootNodeId && !idMapping.has(template.rootNodeId)) {
+            throw new api_errors_1.ValidationError(`Template's root node (${template.rootNodeId}) is missing from template nodes`);
+        }
+        const newRootNodeId = template.rootNodeId
+            ? idMapping.get(template.rootNodeId)
+            : (0, uuid_1.generateUuid)();
+        // Generate new document ID
+        const newDocId = (0, uuid_1.generateUuid)();
+        // Create the cloned document
+        const clonedDocument = {
+            schemaVersion: models_1.CURRENT_DOCUMENT_SCHEMA_VERSION,
+            title: title || `Copy of ${template.title}`,
+            content: template.content || "",
+            owner: userId,
+            sharedWith: [],
+            createdAt: new Date(),
+            rootNodeId: newRootNodeId,
+            isPremiumContent: template.isPremiumContent || false,
+            isTemplate: false,
+            clonedFromTemplateId: templateId,
+            nodes: [] // Nodes stored in sub-collection
+        };
+        // Clone all nodes with new IDs
+        const clonedNodes = nodes.map((node) => {
+            const newNodeId = idMapping.get(node.id);
+            return this._cloneNode(node, newNodeId, userId, idMapping);
+        });
+        // Write everything in a batch
+        const batch = this.firestore.batch();
+        batch.set(`documents/${newDocId}`, clonedDocument);
+        for (const node of clonedNodes) {
+            batch.set(`documents/${newDocId}/nodes/${node.id}`, node);
+        }
+        await batch.commit();
+        return {
+            id: newDocId,
+            ...clonedDocument,
+            nodes: clonedNodes
+        };
+    }
+    async publish(templateId) {
+        this.auth.requireAuth();
+        await this.auth.requireAdmin();
+        // Verify template exists
+        const docData = await this.firestore.getDocument(`documents/${templateId}`);
+        if (!docData) {
+            throw new api_errors_1.NotFoundError(`Template ${templateId} not found`);
+        }
+        if (!docData.isTemplate) {
+            throw new api_errors_1.NotFoundError(`Document ${templateId} is not a template`);
+        }
+        await this.firestore.updateDocument(`documents/${templateId}`, {
+            isPublished: true
+        });
+    }
+    async unpublish(templateId) {
+        this.auth.requireAuth();
+        await this.auth.requireAdmin();
+        // Verify template exists
+        const docData = await this.firestore.getDocument(`documents/${templateId}`);
+        if (!docData) {
+            throw new api_errors_1.NotFoundError(`Template ${templateId} not found`);
+        }
+        if (!docData.isTemplate) {
+            throw new api_errors_1.NotFoundError(`Document ${templateId} is not a template`);
+        }
+        await this.firestore.updateDocument(`documents/${templateId}`, {
+            isPublished: false
+        });
+    }
+    /**
+     * Clones a node with updated IDs and references.
+     * Note: Firestore doesn't allow undefined values, so we conditionally include optional fields.
+     */
+    _cloneNode(node, newNodeId, userId, idMapping) {
+        const clonedElements = node.elements.map((element) => this._cloneElement(element, idMapping));
+        const clonedNode = {
+            id: newNodeId,
+            title: node.title,
+            content: node.content,
+            elements: clonedElements,
+            canvasWidth: node.canvasWidth || DEFAULT_CANVAS_WIDTH,
+            canvasHeight: node.canvasHeight || DEFAULT_CANVAS_HEIGHT,
+            level: node.level,
+            owner: userId
+        };
+        // Only include parentNodeId if it exists (Firestore doesn't allow undefined)
+        if (node.parentNodeId) {
+            clonedNode.parentNodeId = idMapping.get(node.parentNodeId) || node.parentNodeId;
+        }
+        return clonedNode;
+    }
+    /**
+     * Clones an element with updated IDs and references.
+     * Note: Firestore doesn't allow undefined values, so we conditionally include optional fields.
+     */
+    _cloneElement(element, idMapping) {
+        const newElementId = idMapping.get(element.id) || (0, uuid_1.generateUuid)();
+        // Clone properties and update any ID references
+        const clonedProperties = { ...element.properties };
+        // Update connector endpoint references if this is a connector
+        if (element.elementType === "connector" && clonedProperties) {
+            if (clonedProperties["startAnchor"]?.elementId &&
+                idMapping.has(clonedProperties["startAnchor"].elementId)) {
+                clonedProperties["startAnchor"] = {
+                    ...clonedProperties["startAnchor"],
+                    elementId: idMapping.get(clonedProperties["startAnchor"].elementId)
+                };
+            }
+            if (clonedProperties["endAnchor"]?.elementId &&
+                idMapping.has(clonedProperties["endAnchor"].elementId)) {
+                clonedProperties["endAnchor"] = {
+                    ...clonedProperties["endAnchor"],
+                    elementId: idMapping.get(clonedProperties["endAnchor"].elementId)
+                };
+            }
+        }
+        const clonedElement = {
+            id: newElementId,
+            elementType: element.elementType,
+            x: element.x,
+            y: element.y,
+            width: element.width,
+            height: element.height,
+            rotation: element.rotation,
+            properties: clonedProperties
+        };
+        // Only include optional fields if they have values (Firestore doesn't allow undefined)
+        if (element.isLink !== undefined) {
+            clonedElement.isLink = element.isLink;
+        }
+        if (element.linkTarget) {
+            clonedElement.linkTarget = idMapping.get(element.linkTarget) || element.linkTarget;
+        }
+        return clonedElement;
+    }
+}
+exports.TemplateOperations = TemplateOperations;

package/src/lib/testing/mock-auth-client.d.ts

@@ -5,9 +5,11 @@ import { IAuthClient } from "../interfaces/auth-client.interface";
 export declare class MockAuthClient implements IAuthClient {
     private _currentUserId;
     private _isPremium;
+    private _isAdmin;
     constructor(options?: {
         userId?: string;
         isPremium?: boolean;
+        isAdmin?: boolean;
     });
     signIn(email: string, _password: string): Promise<void>;
     signOut(): Promise<void>;
@@ -23,4 +25,10 @@ export declare class MockAuthClient implements IAuthClient {
      * Sets the premium status for testing.
      */
     setPremium(isPremium: boolean): void;
+    isAdmin(): Promise<boolean>;
+    requireAdmin(): Promise<void>;
+    /**
+     * Sets the admin status for testing.
+     */
+    setAdmin(isAdmin: boolean): void;
 }

package/src/lib/testing/mock-auth-client.js

@@ -8,9 +8,11 @@ const api_errors_1 = require("../errors/api-errors");
 class MockAuthClient {
     _currentUserId = null;
     _isPremium = false;
+    _isAdmin = false;
     constructor(options) {
         this._currentUserId = options?.userId ?? null;
         this._isPremium = options?.isPremium ?? false;
+        this._isAdmin = options?.isAdmin ?? false;
     }
     async signIn(email, _password) {
         // Simulate successful sign-in
@@ -49,5 +51,20 @@ class MockAuthClient {
     setPremium(isPremium) {
         this._isPremium = isPremium;
     }
+    async isAdmin() {
+        return this._isAdmin;
+    }
+    async requireAdmin() {
+        this.requireAuth();
+        if (!this._isAdmin) {
+            throw new api_errors_1.PermissionError("Admin access required");
+        }
+    }
+    /**
+     * Sets the admin status for testing.
+     */
+    setAdmin(isAdmin) {
+        this._isAdmin = isAdmin;
+    }
 }
 exports.MockAuthClient = MockAuthClient;

package/src/lib/testing/mock-firestore-client.d.ts

@@ -13,7 +13,7 @@ export declare class MockFirestoreClient implements IFirestoreClient {
     getCollection<T>(path: string): Promise<(T & {
         id: string;
     })[]>;
-    queryCollection<T>(path: string, field: string, value: string): Promise<(T & {
+    queryCollection<T>(path: string, field: string, value: string | number | boolean | null): Promise<(T & {
         id: string;
     })[]>;
     batch(): IBatchWriter;