@progressive-development/pd-provider-mock 0.9.0

package/dist/MockAuthProvider.d.ts

@@ -0,0 +1,47 @@
+import { IAuthProvider, AuthUser, UserToken, AuthStateCallback, Unsubscribe } from '@progressive-development/pd-provider-interfaces';
+import { MockUserFixture, MockProviderConfig } from './fixtures.js';
+/**
+ * Mock implementation of IAuthProvider
+ *
+ * Features:
+ * - JSON fixture-based user configuration
+ * - Optional localStorage persistence
+ * - Configurable delays for realistic testing
+ * - Multiple user support
+ */
+export declare class MockAuthProvider implements IAuthProvider {
+    private users;
+    private currentUser;
+    private currentClaims;
+    private listeners;
+    private config;
+    constructor(users?: MockUserFixture[], config?: MockProviderConfig);
+    login(email: string, password: string): Promise<AuthUser>;
+    logout(): Promise<void>;
+    getCurrentUser(): AuthUser | null;
+    isAuthenticated(): boolean;
+    getIdToken(forceRefresh?: boolean): Promise<string | null>;
+    getIdTokenResult(forceRefresh?: boolean): Promise<UserToken | null>;
+    onAuthStateChanged(callback: AuthStateCallback): Unsubscribe;
+    sendPasswordResetEmail(email: string): Promise<void>;
+    /**
+     * Add a user fixture at runtime
+     */
+    addUser(userFixture: MockUserFixture): void;
+    /**
+     * Set the current user directly (for testing)
+     */
+    setCurrentUser(user: AuthUser | null, claims?: Record<string, unknown>): void;
+    /**
+     * Get all configured users
+     */
+    getConfiguredUsers(): MockUserFixture[];
+    private notifyListeners;
+    private delay;
+    private log;
+    private get storageKey();
+    private persistToStorage;
+    private restoreFromStorage;
+    private clearStorage;
+}
+//# sourceMappingURL=MockAuthProvider.d.ts.map

package/dist/MockAuthProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockAuthProvider.d.ts","sourceRoot":"","sources":["../src/MockAuthProvider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EACb,QAAQ,EACR,SAAS,EACT,iBAAiB,EACjB,WAAW,EACZ,MAAM,iDAAiD,CAAC;AAEzD,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAIzE;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,YAAW,aAAa;IACpD,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,MAAM,CAAqB;gBAEvB,KAAK,GAAE,eAAe,EAAO,EAAE,MAAM,GAAE,kBAAuB;IAUpE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAiCzD,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB7B,cAAc,IAAI,QAAQ,GAAG,IAAI;IAIjC,eAAe,IAAI,OAAO;IAIpB,UAAU,CAAC,YAAY,UAAQ,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAaxD,gBAAgB,CAAC,YAAY,UAAQ,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAoBvE,kBAAkB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,WAAW;IAWtD,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS1D;;OAEG;IACH,OAAO,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;IAI3C;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM7E;;OAEG;IACH,kBAAkB,IAAI,eAAe,EAAE;IAQvC,OAAO,CAAC,eAAe;YAIT,KAAK;IAOnB,OAAO,CAAC,GAAG;IAMX,OAAO,KAAK,UAAU,GAErB;IAED,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,YAAY;CAOrB"}

package/dist/MockAuthProvider.js

@@ -0,0 +1,161 @@
+const DEFAULT_PERSIST_KEY = "pd-mock-auth";
+class MockAuthProvider {
+  constructor(users = [], config = {}) {
+    this.currentUser = null;
+    this.currentClaims = {};
+    this.listeners = /* @__PURE__ */ new Set();
+    this.users = users;
+    this.config = config;
+    if (config.persistAuth) {
+      this.restoreFromStorage();
+    }
+  }
+  async login(email, password) {
+    this.log(`Login attempt for: ${email}`);
+    await this.delay();
+    const userFixture = this.users.find(
+      (u) => u.email === email && u.password === password
+    );
+    if (!userFixture) {
+      const error = new Error("Invalid credentials");
+      error.code = "auth/wrong-password";
+      throw error;
+    }
+    this.currentUser = userFixture.user;
+    this.currentClaims = userFixture.claims || {};
+    if (this.config.persistAuth) {
+      this.persistToStorage();
+    }
+    this.notifyListeners();
+    this.log(`Login successful for: ${email}`);
+    return this.currentUser;
+  }
+  async logout() {
+    this.log("Logout");
+    await this.delay();
+    this.currentUser = null;
+    this.currentClaims = {};
+    if (this.config.persistAuth) {
+      this.clearStorage();
+    }
+    this.notifyListeners();
+  }
+  getCurrentUser() {
+    return this.currentUser;
+  }
+  isAuthenticated() {
+    return this.currentUser !== null;
+  }
+  async getIdToken(forceRefresh = false) {
+    if (!this.currentUser) {
+      return null;
+    }
+    if (forceRefresh) {
+      await this.delay(100);
+    }
+    return `mock-token-${this.currentUser.uid}-${Date.now()}`;
+  }
+  async getIdTokenResult(forceRefresh = false) {
+    if (!this.currentUser) {
+      return null;
+    }
+    if (forceRefresh) {
+      await this.delay(100);
+    }
+    const token = await this.getIdToken();
+    const expirationDate = /* @__PURE__ */ new Date();
+    expirationDate.setHours(expirationDate.getHours() + 1);
+    return {
+      token,
+      claims: this.currentClaims,
+      expirationTime: expirationDate.toISOString()
+    };
+  }
+  onAuthStateChanged(callback) {
+    this.listeners.add(callback);
+    callback(this.currentUser);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  async sendPasswordResetEmail(email) {
+    this.log(`Password reset email "sent" to: ${email}`);
+    await this.delay();
+  }
+  // -------------------------------------------------------------------------
+  // Mock-specific Methods
+  // -------------------------------------------------------------------------
+  /**
+   * Add a user fixture at runtime
+   */
+  addUser(userFixture) {
+    this.users.push(userFixture);
+  }
+  /**
+   * Set the current user directly (for testing)
+   */
+  setCurrentUser(user, claims) {
+    this.currentUser = user;
+    this.currentClaims = claims || {};
+    this.notifyListeners();
+  }
+  /**
+   * Get all configured users
+   */
+  getConfiguredUsers() {
+    return [...this.users];
+  }
+  // -------------------------------------------------------------------------
+  // Private Helpers
+  // -------------------------------------------------------------------------
+  notifyListeners() {
+    this.listeners.forEach((callback) => callback(this.currentUser));
+  }
+  async delay(ms) {
+    const delayMs = ms ?? this.config.defaultDelay ?? 500;
+    if (delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  log(message) {
+    if (this.config.logging) {
+      console.log(`[MockAuth] ${message}`);
+    }
+  }
+  get storageKey() {
+    return this.config.persistAuthKey || DEFAULT_PERSIST_KEY;
+  }
+  persistToStorage() {
+    try {
+      const data = {
+        user: this.currentUser,
+        claims: this.currentClaims
+      };
+      localStorage.setItem(this.storageKey, JSON.stringify(data));
+    } catch (e) {
+      this.log(`Failed to persist auth: ${e}`);
+    }
+  }
+  restoreFromStorage() {
+    try {
+      const stored = localStorage.getItem(this.storageKey);
+      if (stored) {
+        const data = JSON.parse(stored);
+        this.currentUser = data.user;
+        this.currentClaims = data.claims || {};
+        this.log(`Restored auth from storage: ${this.currentUser?.email}`);
+      }
+    } catch (e) {
+      this.log(`Failed to restore auth: ${e}`);
+    }
+  }
+  clearStorage() {
+    try {
+      localStorage.removeItem(this.storageKey);
+    } catch (e) {
+      this.log(`Failed to clear auth storage: ${e}`);
+    }
+  }
+}
+
+export { MockAuthProvider };

package/dist/MockDatabaseProvider.d.ts

@@ -0,0 +1,44 @@
+import { IDatabaseProvider, QueryConstraint, DocumentSnapshot, CollectionCallback, Unsubscribe } from '@progressive-development/pd-provider-interfaces';
+import { MockDatabaseCollection, MockDatabaseDocument, MockProviderConfig } from './fixtures.js';
+/**
+ * Mock implementation of IDatabaseProvider
+ *
+ * Features:
+ * - JSON fixture-based collection data
+ * - In-memory document operations
+ * - Collection listeners with real-time updates
+ * - Query constraint filtering
+ */
+export declare class MockDatabaseProvider implements IDatabaseProvider {
+    private collections;
+    private subscriptions;
+    private config;
+    constructor(fixtures?: MockDatabaseCollection[], config?: MockProviderConfig);
+    onCollection<T = unknown>(collectionPath: string, callback: CollectionCallback<T>, constraints?: QueryConstraint[]): Unsubscribe;
+    getDocument<T = unknown>(collectionPath: string, documentId: string): Promise<DocumentSnapshot<T>>;
+    setDocument<T = unknown>(collectionPath: string, documentId: string, data: T): Promise<void>;
+    updateDocument(collectionPath: string, documentId: string, data: Record<string, unknown>): Promise<void>;
+    deleteDocument(collectionPath: string, documentId: string): Promise<void>;
+    /**
+     * Add a collection fixture at runtime
+     */
+    addCollection(path: string, documents: MockDatabaseDocument[]): void;
+    /**
+     * Clear a collection
+     */
+    clearCollection(path: string): void;
+    /**
+     * Clear all collections
+     */
+    clearAllCollections(): void;
+    /**
+     * Get all documents in a collection (without filtering)
+     */
+    getAllDocuments<T>(collectionPath: string): MockDatabaseDocument<T>[];
+    private getFilteredDocuments;
+    private matchesConstraints;
+    private notifySubscribers;
+    private delay;
+    private log;
+}
+//# sourceMappingURL=MockDatabaseProvider.d.ts.map

package/dist/MockDatabaseProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockDatabaseProvider.d.ts","sourceRoot":"","sources":["../src/MockDatabaseProvider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,EACZ,MAAM,iDAAiD,CAAC;AAEzD,OAAO,KAAK,EACV,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AAWvB;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,YAAW,iBAAiB;IAC5D,OAAO,CAAC,WAAW,CAAkD;IACrE,OAAO,CAAC,aAAa,CAAmD;IACxE,OAAO,CAAC,MAAM,CAAqB;gBAGjC,QAAQ,GAAE,sBAAsB,EAAO,EACvC,MAAM,GAAE,kBAAuB;IAUjC,YAAY,CAAC,CAAC,GAAG,OAAO,EACtB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,WAAW,CAAC,EAAE,eAAe,EAAE,GAC9B,WAAW;IAqBR,WAAW,CAAC,CAAC,GAAG,OAAO,EAC3B,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAezB,WAAW,CAAC,CAAC,GAAG,OAAO,EAC3B,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,CAAC,GACN,OAAO,CAAC,IAAI,CAAC;IAuBV,cAAc,CAClB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,IAAI,CAAC;IAsBV,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB/E;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,oBAAoB,EAAE,GAAG,IAAI;IAKpE;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKnC;;OAEG;IACH,mBAAmB,IAAI,IAAI;IAM3B;;OAEG;IACH,eAAe,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,GAAG,oBAAoB,CAAC,CAAC,CAAC,EAAE;IAQrE,OAAO,CAAC,oBAAoB;IAoB5B,OAAO,CAAC,kBAAkB;IAyD1B,OAAO,CAAC,iBAAiB;YAYX,KAAK;IAOnB,OAAO,CAAC,GAAG;CAKZ"}

package/dist/MockDatabaseProvider.js

@@ -0,0 +1,196 @@
+class MockDatabaseProvider {
+  constructor(fixtures = [], config = {}) {
+    this.collections = /* @__PURE__ */ new Map();
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this.config = config;
+    for (const fixture of fixtures) {
+      this.collections.set(fixture.path, [...fixture.documents]);
+    }
+  }
+  onCollection(collectionPath, callback, constraints) {
+    this.log(`Subscribing to collection: ${collectionPath}`);
+    const subscription = {
+      path: collectionPath,
+      callback,
+      constraints
+    };
+    this.subscriptions.add(subscription);
+    const documents = this.getFilteredDocuments(collectionPath, constraints);
+    callback(documents);
+    return () => {
+      this.subscriptions.delete(subscription);
+      this.log(`Unsubscribed from collection: ${collectionPath}`);
+    };
+  }
+  async getDocument(collectionPath, documentId) {
+    this.log(`Getting document: ${collectionPath}/${documentId}`);
+    await this.delay();
+    const collection = this.collections.get(collectionPath) || [];
+    const doc = collection.find((d) => d.id === documentId);
+    return {
+      id: documentId,
+      data: doc?.data ?? {},
+      exists: !!doc
+    };
+  }
+  async setDocument(collectionPath, documentId, data) {
+    this.log(`Setting document: ${collectionPath}/${documentId}`);
+    await this.delay();
+    let collection = this.collections.get(collectionPath);
+    if (!collection) {
+      collection = [];
+      this.collections.set(collectionPath, collection);
+    }
+    const existingIndex = collection.findIndex((d) => d.id === documentId);
+    if (existingIndex >= 0) {
+      collection[existingIndex] = { id: documentId, data };
+    } else {
+      collection.push({ id: documentId, data });
+    }
+    this.notifySubscribers(collectionPath);
+  }
+  async updateDocument(collectionPath, documentId, data) {
+    this.log(`Updating document: ${collectionPath}/${documentId}`);
+    await this.delay();
+    const collection = this.collections.get(collectionPath);
+    if (!collection) {
+      throw new Error(`Collection not found: ${collectionPath}`);
+    }
+    const doc = collection.find((d) => d.id === documentId);
+    if (!doc) {
+      throw new Error(`Document not found: ${collectionPath}/${documentId}`);
+    }
+    doc.data = { ...doc.data, ...data };
+    this.notifySubscribers(collectionPath);
+  }
+  async deleteDocument(collectionPath, documentId) {
+    this.log(`Deleting document: ${collectionPath}/${documentId}`);
+    await this.delay();
+    const collection = this.collections.get(collectionPath);
+    if (!collection) {
+      return;
+    }
+    const index = collection.findIndex((d) => d.id === documentId);
+    if (index >= 0) {
+      collection.splice(index, 1);
+    }
+    this.notifySubscribers(collectionPath);
+  }
+  // -------------------------------------------------------------------------
+  // Mock-specific Methods
+  // -------------------------------------------------------------------------
+  /**
+   * Add a collection fixture at runtime
+   */
+  addCollection(path, documents) {
+    this.collections.set(path, [...documents]);
+    this.notifySubscribers(path);
+  }
+  /**
+   * Clear a collection
+   */
+  clearCollection(path) {
+    this.collections.delete(path);
+    this.notifySubscribers(path);
+  }
+  /**
+   * Clear all collections
+   */
+  clearAllCollections() {
+    const paths = [...this.collections.keys()];
+    this.collections.clear();
+    paths.forEach((path) => this.notifySubscribers(path));
+  }
+  /**
+   * Get all documents in a collection (without filtering)
+   */
+  getAllDocuments(collectionPath) {
+    return this.collections.get(collectionPath) || [];
+  }
+  // -------------------------------------------------------------------------
+  // Private Helpers
+  // -------------------------------------------------------------------------
+  getFilteredDocuments(collectionPath, constraints) {
+    let documents = this.collections.get(collectionPath) || [];
+    if (constraints && constraints.length > 0) {
+      documents = documents.filter(
+        (doc) => this.matchesConstraints(doc.data, constraints)
+      );
+    }
+    return documents.map((doc) => ({
+      id: doc.id,
+      data: doc.data,
+      exists: true
+    }));
+  }
+  matchesConstraints(data, constraints) {
+    for (const constraint of constraints) {
+      if (constraint.type !== "where") {
+        continue;
+      }
+      const fieldValue = data[constraint.field];
+      const targetValue = constraint.value;
+      let matches = false;
+      switch (constraint.operator) {
+        case "==":
+          matches = fieldValue === targetValue;
+          break;
+        case "!=":
+          matches = fieldValue !== targetValue;
+          break;
+        case "<":
+          matches = fieldValue < targetValue;
+          break;
+        case "<=":
+          matches = fieldValue <= targetValue;
+          break;
+        case ">":
+          matches = fieldValue > targetValue;
+          break;
+        case ">=":
+          matches = fieldValue >= targetValue;
+          break;
+        case "array-contains":
+          matches = Array.isArray(fieldValue) && fieldValue.includes(targetValue);
+          break;
+        case "array-contains-any":
+          matches = Array.isArray(fieldValue) && Array.isArray(targetValue) && targetValue.some((v) => fieldValue.includes(v));
+          break;
+        case "in":
+          matches = Array.isArray(targetValue) && targetValue.includes(fieldValue);
+          break;
+        case "not-in":
+          matches = Array.isArray(targetValue) && !targetValue.includes(fieldValue);
+          break;
+      }
+      if (!matches) {
+        return false;
+      }
+    }
+    return true;
+  }
+  notifySubscribers(collectionPath) {
+    for (const subscription of this.subscriptions) {
+      if (subscription.path === collectionPath) {
+        const documents = this.getFilteredDocuments(
+          collectionPath,
+          subscription.constraints
+        );
+        subscription.callback(documents);
+      }
+    }
+  }
+  async delay() {
+    const delayMs = this.config.defaultDelay ?? 100;
+    if (delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  log(message) {
+    if (this.config.logging) {
+      console.log(`[MockDatabase] ${message}`);
+    }
+  }
+}
+
+export { MockDatabaseProvider };

package/dist/MockFunctionProvider.d.ts

@@ -0,0 +1,43 @@
+import { IFunctionProvider, FunctionResult } from '@progressive-development/pd-provider-interfaces';
+import { MockFunctionFixture, MockProviderConfig } from './fixtures.js';
+/**
+ * Mock implementation of IFunctionProvider
+ *
+ * Features:
+ * - JSON fixture-based function responses
+ * - Input matching for conditional responses
+ * - Configurable delays
+ * - Error simulation
+ */
+export declare class MockFunctionProvider implements IFunctionProvider {
+    private fixtures;
+    private config;
+    private region;
+    constructor(fixtures?: MockFunctionFixture[], config?: MockProviderConfig);
+    callFunction(functionName: string, data: unknown): Promise<FunctionResult>;
+    setRegion(region: string): void;
+    /**
+     * Add a function fixture at runtime
+     */
+    addFixture(fixture: MockFunctionFixture): void;
+    /**
+     * Remove all fixtures for a function
+     */
+    removeFixtures(functionName: string): void;
+    /**
+     * Clear all fixtures
+     */
+    clearFixtures(): void;
+    /**
+     * Set fixtures (replace all)
+     */
+    setFixtures(fixtures: MockFunctionFixture[]): void;
+    /**
+     * Get configured region
+     */
+    getRegion(): string;
+    private findMatchingFixture;
+    private matchesInput;
+    private log;
+}
+//# sourceMappingURL=MockFunctionProvider.d.ts.map

package/dist/MockFunctionProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockFunctionProvider.d.ts","sourceRoot":"","sources":["../src/MockFunctionProvider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACf,MAAM,iDAAiD,CAAC;AAEzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAE7E;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,YAAW,iBAAiB;IAC5D,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,MAAM,CAAiB;gBAEnB,QAAQ,GAAE,mBAAmB,EAAO,EAAE,MAAM,GAAE,kBAAuB;IAK3E,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IA8BhF,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAS/B;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAI9C;;OAEG;IACH,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAI1C;;OAEG;IACH,aAAa,IAAI,IAAI;IAIrB;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,IAAI;IAIlD;;OAEG;IACH,SAAS,IAAI,MAAM;IAQnB,OAAO,CAAC,mBAAmB;IA6B3B,OAAO,CAAC,YAAY;IAoBpB,OAAO,CAAC,GAAG;CASZ"}

package/dist/MockFunctionProvider.js

@@ -0,0 +1,108 @@
+class MockFunctionProvider {
+  constructor(fixtures = [], config = {}) {
+    this.region = "mock-region";
+    this.fixtures = fixtures;
+    this.config = config;
+  }
+  async callFunction(functionName, data) {
+    this.log(`Calling function: ${functionName}`, data);
+    const fixture = this.findMatchingFixture(functionName, data);
+    if (!fixture) {
+      this.log(`No fixture found for: ${functionName}`);
+      throw new Error(`Mock: No fixture configured for function "${functionName}"`);
+    }
+    const delay = fixture.response.delay ?? this.config.defaultDelay ?? 500;
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    if (fixture.response.error) {
+      const error = new Error(fixture.response.error.message);
+      if (fixture.response.error.code) {
+        error.code = fixture.response.error.code;
+      }
+      throw error;
+    }
+    this.log(`Returning result for: ${functionName}`, fixture.response.result);
+    return fixture.response.result;
+  }
+  setRegion(region) {
+    this.region = region;
+    this.log(`Region set to: ${region}`);
+  }
+  // -------------------------------------------------------------------------
+  // Mock-specific Methods
+  // -------------------------------------------------------------------------
+  /**
+   * Add a function fixture at runtime
+   */
+  addFixture(fixture) {
+    this.fixtures.push(fixture);
+  }
+  /**
+   * Remove all fixtures for a function
+   */
+  removeFixtures(functionName) {
+    this.fixtures = this.fixtures.filter((f) => f.name !== functionName);
+  }
+  /**
+   * Clear all fixtures
+   */
+  clearFixtures() {
+    this.fixtures = [];
+  }
+  /**
+   * Set fixtures (replace all)
+   */
+  setFixtures(fixtures) {
+    this.fixtures = fixtures;
+  }
+  /**
+   * Get configured region
+   */
+  getRegion() {
+    return this.region;
+  }
+  // -------------------------------------------------------------------------
+  // Private Helpers
+  // -------------------------------------------------------------------------
+  findMatchingFixture(functionName, data) {
+    const matchingByName = this.fixtures.filter((f) => f.name === functionName);
+    if (matchingByName.length === 0) {
+      return void 0;
+    }
+    if (matchingByName.length === 1 && !matchingByName[0].inputMatcher) {
+      return matchingByName[0];
+    }
+    const withMatcher = matchingByName.filter((f) => f.inputMatcher);
+    for (const fixture of withMatcher) {
+      if (this.matchesInput(fixture.inputMatcher, data)) {
+        return fixture;
+      }
+    }
+    const withoutMatcher = matchingByName.find((f) => !f.inputMatcher);
+    return withoutMatcher;
+  }
+  matchesInput(matcher, data) {
+    if (!data || typeof data !== "object") {
+      return false;
+    }
+    const dataObj = data;
+    for (const [key, value] of Object.entries(matcher)) {
+      if (dataObj[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  log(message, data) {
+    if (this.config.logging) {
+      if (data !== void 0) {
+        console.log(`[MockFunction] ${message}`, data);
+      } else {
+        console.log(`[MockFunction] ${message}`);
+      }
+    }
+  }
+}
+
+export { MockFunctionProvider };

package/dist/MockStorageProvider.d.ts

@@ -0,0 +1,43 @@
+import { IStorageProvider, UploadFileRequest, UploadResult, StorageDocument, ListFilesOptions, GetFileOptions } from '@progressive-development/pd-provider-interfaces';
+import { MockStorageFixture, MockStorageFile, MockProviderConfig } from './fixtures.js';
+/**
+ * Mock implementation of IStorageProvider
+ *
+ * Features:
+ * - JSON fixture-based file configuration
+ * - In-memory upload storage
+ * - Configurable delays
+ */
+export declare class MockStorageProvider implements IStorageProvider {
+    private fixtures;
+    private config;
+    /** In-memory storage for uploaded files */
+    private uploadedFiles;
+    constructor(fixtures?: MockStorageFixture[], config?: MockProviderConfig);
+    uploadFile(request: UploadFileRequest): Promise<UploadResult>;
+    downloadFile(options: GetFileOptions): Promise<string>;
+    deleteFile(options: GetFileOptions): Promise<void>;
+    listFiles(options: ListFilesOptions): Promise<StorageDocument[]>;
+    getFile(options: GetFileOptions): Promise<StorageDocument | null>;
+    /**
+     * Add a storage fixture at runtime
+     */
+    addFixture(fixture: MockStorageFixture): void;
+    /**
+     * Clear all uploaded files (in-memory)
+     */
+    clearUploads(): void;
+    /**
+     * Get all uploaded files
+     */
+    getUploadedFiles(): Map<string, MockStorageFile>;
+    /**
+     * Set fixtures (replace all)
+     */
+    setFixtures(fixtures: MockStorageFixture[]): void;
+    private buildFilePath;
+    private findFileInFixtures;
+    private delay;
+    private log;
+}
+//# sourceMappingURL=MockStorageProvider.d.ts.map

package/dist/MockStorageProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockStorageProvider.d.ts","sourceRoot":"","sources":["../src/MockStorageProvider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,cAAc,EACf,MAAM,iDAAiD,CAAC;AAEzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAE7F;;;;;;;GAOG;AACH,qBAAa,mBAAoB,YAAW,gBAAgB;IAC1D,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,MAAM,CAAqB;IACnC,2CAA2C;IAC3C,OAAO,CAAC,aAAa,CAA2C;gBAEpD,QAAQ,GAAE,kBAAkB,EAAO,EAAE,MAAM,GAAE,kBAAuB;IAK1E,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC;IAwC7D,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IA4BtD,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBlD,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA8ChE,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IA2BvE;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAI7C;;OAEG;IACH,YAAY,IAAI,IAAI;IAIpB;;OAEG;IACH,gBAAgB,IAAI,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC;IAIhD;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,kBAAkB,EAAE,GAAG,IAAI;IAQjD,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,kBAAkB;YAmBZ,KAAK;IAOnB,OAAO,CAAC,GAAG;CAKZ"}