@graph-knowledge/api 0.1.4 → 0.1.6

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
@@ -243,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):
@@ -379,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.4",
+  "version": "0.1.6",
   "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,9 +6,10 @@ 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";
+export type { BaseElementInput, RectangleInput, TextInput, ConnectorInput, ConnectorAnchor, LineStyle, MarkerType, UmlClassInput, UmlInterfaceInput, UmlComponentInput, UmlPackageInput, UmlArtifactInput, UmlNoteInput, TriangleInput, DiamondInput, HexagonInput, EllipseInput, LineInput, BlockArrowInput, BlockArrowDirection, CustomShapeInput, AnyElementInput, UpdateElementInput } from "./lib/types/element-input-types";
 export { GraphKnowledgeAPIError, AuthenticationError, NotFoundError, ValidationError, PermissionError } from "./lib/errors/api-errors";
 export type { Document, GraphNode, GraphElement } from "./lib/models";
 export { CURRENT_DOCUMENT_SCHEMA_VERSION } from "./lib/models";

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/constants/element-defaults.js

@@ -14,7 +14,13 @@ exports.DEFAULT_ELEMENT_DIMENSIONS = {
     "uml-component": { width: 150, height: 100 },
     "uml-package": { width: 200, height: 150 },
     "uml-artifact": { width: 100, height: 80 },
-    "uml-note": { width: 150, height: 100 }
+    "uml-note": { width: 150, height: 100 },
+    triangle: { width: 120, height: 100 },
+    diamond: { width: 100, height: 100 },
+    hexagon: { width: 120, height: 104 },
+    ellipse: { width: 150, height: 100 },
+    line: { width: 150, height: 0 },
+    "block-arrow": { width: 150, height: 80 }
 };
 /**
  * Default dimensions for custom shapes.

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;

package/src/lib/types/element-input-types.d.ts

@@ -201,6 +201,84 @@ export interface UmlNoteInput extends BaseElementInput {
     /** Stroke width in pixels */
     strokeWidth?: number;
 }
+/**
+ * Input for creating a triangle element.
+ */
+export interface TriangleInput extends BaseElementInput {
+    type: "triangle";
+    /** Fill color (hex, e.g., "#FF5733") */
+    fillColor?: string;
+    /** Stroke color (hex) */
+    strokeColor?: string;
+    /** Stroke width in pixels */
+    strokeWidth?: number;
+}
+/**
+ * Input for creating a diamond element.
+ */
+export interface DiamondInput extends BaseElementInput {
+    type: "diamond";
+    /** Fill color (hex, e.g., "#FF5733") */
+    fillColor?: string;
+    /** Stroke color (hex) */
+    strokeColor?: string;
+    /** Stroke width in pixels */
+    strokeWidth?: number;
+}
+/**
+ * Input for creating a hexagon element.
+ */
+export interface HexagonInput extends BaseElementInput {
+    type: "hexagon";
+    /** Fill color (hex, e.g., "#FF5733") */
+    fillColor?: string;
+    /** Stroke color (hex) */
+    strokeColor?: string;
+    /** Stroke width in pixels */
+    strokeWidth?: number;
+}
+/**
+ * Input for creating an ellipse element.
+ */
+export interface EllipseInput extends BaseElementInput {
+    type: "ellipse";
+    /** Fill color (hex, e.g., "#FF5733") */
+    fillColor?: string;
+    /** Stroke color (hex) */
+    strokeColor?: string;
+    /** Stroke width in pixels */
+    strokeWidth?: number;
+}
+/**
+ * Input for creating a line element.
+ */
+export interface LineInput extends BaseElementInput {
+    type: "line";
+    /** Stroke color (hex) */
+    strokeColor?: string;
+    /** Stroke width in pixels */
+    strokeWidth?: number;
+    /** Line style (reuses LineStyle from connectors) */
+    lineStyle?: LineStyle;
+}
+/**
+ * Direction for block arrow elements.
+ */
+export type BlockArrowDirection = "right" | "left" | "up" | "down";
+/**
+ * Input for creating a block arrow element.
+ */
+export interface BlockArrowInput extends BaseElementInput {
+    type: "block-arrow";
+    /** Fill color (hex, e.g., "#FF5733") */
+    fillColor?: string;
+    /** Stroke color (hex) */
+    strokeColor?: string;
+    /** Stroke width in pixels */
+    strokeWidth?: number;
+    /** Arrow direction */
+    direction?: BlockArrowDirection;
+}
 /**
  * Input for creating a custom shape element.
  */
@@ -220,7 +298,7 @@ export interface CustomShapeInput extends BaseElementInput {
 /**
  * Union of all element input types.
  */
-export type AnyElementInput = RectangleInput | TextInput | ConnectorInput | UmlClassInput | UmlInterfaceInput | UmlComponentInput | UmlPackageInput | UmlArtifactInput | UmlNoteInput | CustomShapeInput;
+export type AnyElementInput = RectangleInput | TextInput | ConnectorInput | UmlClassInput | UmlInterfaceInput | UmlComponentInput | UmlPackageInput | UmlArtifactInput | UmlNoteInput | TriangleInput | DiamondInput | HexagonInput | EllipseInput | LineInput | BlockArrowInput | CustomShapeInput;
 /**
  * Input for updating an existing element.
  */

package/src/lib/validators/element-type-validators/basic-shape-validators.d.ts

@@ -0,0 +1,36 @@
+import { IElementTypeValidator } from "../../interfaces/element-validator.interface";
+import { AnyElementInput } from "../../types/element-input-types";
+import { BaseElementValidator } from "./base-element-validator";
+/**
+ * Base validator for basic shapes (triangle, diamond, hexagon, ellipse).
+ * All these shapes share the same properties: fillColor, strokeColor, strokeWidth.
+ */
+declare abstract class BasicShapeValidator extends BaseElementValidator implements IElementTypeValidator {
+    abstract readonly elementType: string;
+    validate(input: AnyElementInput): void;
+}
+/**
+ * Validator for triangle elements.
+ */
+export declare class TriangleValidator extends BasicShapeValidator {
+    readonly elementType = "triangle";
+}
+/**
+ * Validator for diamond elements.
+ */
+export declare class DiamondValidator extends BasicShapeValidator {
+    readonly elementType = "diamond";
+}
+/**
+ * Validator for hexagon elements.
+ */
+export declare class HexagonValidator extends BasicShapeValidator {
+    readonly elementType = "hexagon";
+}
+/**
+ * Validator for ellipse elements.
+ */
+export declare class EllipseValidator extends BasicShapeValidator {
+    readonly elementType = "ellipse";
+}
+export {};

package/src/lib/validators/element-type-validators/basic-shape-validators.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EllipseValidator = exports.HexagonValidator = exports.DiamondValidator = exports.TriangleValidator = void 0;
+const api_errors_1 = require("../../errors/api-errors");
+const base_element_validator_1 = require("./base-element-validator");
+/**
+ * Base validator for basic shapes (triangle, diamond, hexagon, ellipse).
+ * All these shapes share the same properties: fillColor, strokeColor, strokeWidth.
+ */
+class BasicShapeValidator extends base_element_validator_1.BaseElementValidator {
+    validate(input) {
+        if (input.type !== this.elementType) {
+            throw new api_errors_1.ValidationError(`Expected type "${this.elementType}", got "${input.type}"`, "type");
+        }
+        const shapeInput = input;
+        // Validate common properties
+        this.validateCommon(shapeInput);
+        // Validate shape-specific properties
+        this.validateColor(shapeInput.fillColor, "fillColor");
+        this.validateColor(shapeInput.strokeColor, "strokeColor");
+        this.validateStrokeWidth(shapeInput.strokeWidth, "strokeWidth");
+    }
+}
+/**
+ * Validator for triangle elements.
+ */
+class TriangleValidator extends BasicShapeValidator {
+    elementType = "triangle";
+}
+exports.TriangleValidator = TriangleValidator;
+/**
+ * Validator for diamond elements.
+ */
+class DiamondValidator extends BasicShapeValidator {
+    elementType = "diamond";
+}
+exports.DiamondValidator = DiamondValidator;
+/**
+ * Validator for hexagon elements.
+ */
+class HexagonValidator extends BasicShapeValidator {
+    elementType = "hexagon";
+}
+exports.HexagonValidator = HexagonValidator;
+/**
+ * Validator for ellipse elements.
+ */
+class EllipseValidator extends BasicShapeValidator {
+    elementType = "ellipse";
+}
+exports.EllipseValidator = EllipseValidator;

package/src/lib/validators/element-type-validators/block-arrow-validator.d.ts

@@ -0,0 +1,11 @@
+import { IElementTypeValidator } from "../../interfaces/element-validator.interface";
+import { AnyElementInput } from "../../types/element-input-types";
+import { BaseElementValidator } from "./base-element-validator";
+/**
+ * Validator for block arrow elements.
+ */
+export declare class BlockArrowValidator extends BaseElementValidator implements IElementTypeValidator {
+    readonly elementType = "block-arrow";
+    validate(input: AnyElementInput): void;
+    private validateDirection;
+}

package/src/lib/validators/element-type-validators/block-arrow-validator.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockArrowValidator = void 0;
+const api_errors_1 = require("../../errors/api-errors");
+const base_element_validator_1 = require("./base-element-validator");
+/**
+ * Validator for block arrow elements.
+ */
+class BlockArrowValidator extends base_element_validator_1.BaseElementValidator {
+    elementType = "block-arrow";
+    validate(input) {
+        if (input.type !== "block-arrow") {
+            throw new api_errors_1.ValidationError(`Expected type "block-arrow", got "${input.type}"`, "type");
+        }
+        const blockArrowInput = input;
+        // Validate common properties
+        this.validateCommon(blockArrowInput);
+        // Validate block-arrow-specific properties
+        this.validateColor(blockArrowInput.fillColor, "fillColor");
+        this.validateColor(blockArrowInput.strokeColor, "strokeColor");
+        this.validateStrokeWidth(blockArrowInput.strokeWidth, "strokeWidth");
+        this.validateDirection(blockArrowInput.direction);
+    }
+    validateDirection(value) {
+        if (value === undefined)
+            return;
+        if (typeof value !== "string") {
+            throw new api_errors_1.ValidationError("direction must be a string", "direction");
+        }
+        const validDirections = ["right", "left", "up", "down"];
+        if (!validDirections.includes(value)) {
+            throw new api_errors_1.ValidationError(`direction must be one of: ${validDirections.join(", ")}`, "direction");
+        }
+    }
+}
+exports.BlockArrowValidator = BlockArrowValidator;

package/src/lib/validators/element-type-validators/line-validator.d.ts

@@ -0,0 +1,11 @@
+import { IElementTypeValidator } from "../../interfaces/element-validator.interface";
+import { AnyElementInput } from "../../types/element-input-types";
+import { BaseElementValidator } from "./base-element-validator";
+/**
+ * Validator for line elements.
+ */
+export declare class LineValidator extends BaseElementValidator implements IElementTypeValidator {
+    readonly elementType = "line";
+    validate(input: AnyElementInput): void;
+    private validateLineStyle;
+}

package/src/lib/validators/element-type-validators/line-validator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineValidator = void 0;
+const api_errors_1 = require("../../errors/api-errors");
+const base_element_validator_1 = require("./base-element-validator");
+/**
+ * Validator for line elements.
+ */
+class LineValidator extends base_element_validator_1.BaseElementValidator {
+    elementType = "line";
+    validate(input) {
+        if (input.type !== "line") {
+            throw new api_errors_1.ValidationError(`Expected type "line", got "${input.type}"`, "type");
+        }
+        const lineInput = input;
+        // Validate common properties
+        this.validateCommon(lineInput);
+        // Validate line-specific properties
+        this.validateColor(lineInput.strokeColor, "strokeColor");
+        this.validateStrokeWidth(lineInput.strokeWidth, "strokeWidth");
+        this.validateLineStyle(lineInput.lineStyle);
+    }
+    validateLineStyle(value) {
+        if (value === undefined)
+            return;
+        if (typeof value !== "string") {
+            throw new api_errors_1.ValidationError("lineStyle must be a string", "lineStyle");
+        }
+        const validStyles = ["solid", "dashed", "dotted"];
+        if (!validStyles.includes(value)) {
+            throw new api_errors_1.ValidationError(`lineStyle must be one of: ${validStyles.join(", ")}`, "lineStyle");
+        }
+    }
+}
+exports.LineValidator = LineValidator;

package/src/lib/validators/element-validator-registry.js

@@ -6,6 +6,9 @@ const rectangle_validator_1 = require("./element-type-validators/rectangle-valid
 const text_validator_1 = require("./element-type-validators/text-validator");
 const connector_validator_1 = require("./element-type-validators/connector-validator");
 const uml_validators_1 = require("./element-type-validators/uml-validators");
+const basic_shape_validators_1 = require("./element-type-validators/basic-shape-validators");
+const line_validator_1 = require("./element-type-validators/line-validator");
+const block_arrow_validator_1 = require("./element-type-validators/block-arrow-validator");
 const custom_shape_validator_1 = require("./element-type-validators/custom-shape-validator");
 /**
  * Registry for element type validators.
@@ -31,6 +34,12 @@ class ElementValidatorRegistry {
         this.register(new uml_validators_1.UmlPackageValidator());
         this.register(new uml_validators_1.UmlArtifactValidator());
         this.register(new uml_validators_1.UmlNoteValidator());
+        this.register(new basic_shape_validators_1.TriangleValidator());
+        this.register(new basic_shape_validators_1.DiamondValidator());
+        this.register(new basic_shape_validators_1.HexagonValidator());
+        this.register(new basic_shape_validators_1.EllipseValidator());
+        this.register(new line_validator_1.LineValidator());
+        this.register(new block_arrow_validator_1.BlockArrowValidator());
     }
     register(validator) {
         this.validators.set(validator.elementType, validator);