@superbright/indexeddb-orm 0.1.1

package/src/adapters/structured-store.ts

@@ -0,0 +1,85 @@
+import {
+  type ZustandUnifiedStoreState,
+  createZustandUnifiedStore,
+  type Filters,
+  type UnitData,
+  type TourContactData,
+  type QueryParams
+} from "./zustand-unified";
+
+export interface StructuredStoreActions {
+  property: {
+    unit: {
+      favorites: {
+        toggle: (unitId: string) => Promise<void>;
+      };
+      viewed: {
+        mark: (unitId: string, slug: string) => Promise<void>;
+      };
+    };
+    questionnaire: {
+      setResults: (results: unknown) => Promise<void>;
+    };
+    tour: {
+      setContactedOn: () => Promise<void>;
+      getContactedOn: () => Promise<string | null>;
+      setContactData: (data: TourContactData) => Promise<void>;
+    };
+  };
+
+  filters: {
+    set: (filters: Partial<Filters>) => Promise<void>;
+    setTemp: (filters: Partial<Filters>) => Promise<void>;
+    setToDefault: () => Promise<void>;
+    commitTemp: <K extends keyof Filters>(key: K, defaultValue: Filters[K]) => Promise<void>;
+    commitAvailability: () => Promise<void>;
+    submit: () => Promise<void>;
+  };
+}
+
+export function createStructuredStoreActions(store: ZustandUnifiedStoreState): StructuredStoreActions {
+  return {
+    property: {
+      unit: {
+        favorites: {
+          toggle: store.toggleFavorite.bind(store),
+        },
+        viewed: {
+          mark: store.markUnitAsViewed.bind(store),
+        },
+      },
+      questionnaire: {
+        setResults: store.setQuestionnaireResults.bind(store),
+      },
+      tour: {
+        setContactedOn: store.setTourContactedOn.bind(store),
+        getContactedOn: store.getTourContactedOn.bind(store),
+        setContactData: store.setTourContactData.bind(store),
+      },
+    },
+    filters: {
+      set: store.setFilters.bind(store),
+      setTemp: store.setTempFilters.bind(store),
+      setToDefault: store.setFiltersToDefault.bind(store),
+      commitTemp: store.commitTempFilterChange.bind(store),
+      commitAvailability: store.commitAvailabilityChange.bind(store),
+      submit: store.submitFilterUpdate.bind(store),
+    },
+  };
+}
+
+export type StructuredStore = ZustandUnifiedStoreState & StructuredStoreActions;
+
+export function createStructuredStore(options?: {
+  onFilterUpdate?: (apiParams: QueryParams) => void;
+}) {
+  return (set: any, get: any): StructuredStore => {
+    const baseStore = createZustandUnifiedStore(options)(set, get);
+    const actions = createStructuredStoreActions(baseStore);
+
+    return {
+      ...baseStore,
+      ...actions,
+    };
+  };
+}

package/src/adapters/zustand-app.ts

@@ -0,0 +1,221 @@
+import { appStore, type AppStoreData, type UnitData, type Filters, type QueryParams, type ResultsMode, type SortBy } from "../api/app";
+
+// Zustand-compatible app store interface
+export interface ZustandAppStoreState {
+  data: Record<string, UnitData>;
+  filters: Filters;
+  tempFilters: Filters;
+  apiFilters: QueryParams;
+  resultsMode: ResultsMode;
+  propertySlug: string | null;
+  resolvedQuestionnaireValues: Record<string, string[]>;
+  sortBy: SortBy;
+  filtersLoaded: boolean;
+
+  // Async actions
+  setData: (key: string, value: UnitData) => Promise<void>;
+  removeData: (key: string) => Promise<void>;
+  clearData: () => Promise<void>;
+  setFilters: (filters: Partial<Filters>) => Promise<void>;
+  setTempFilters: (filters: Partial<Filters>) => Promise<void>;
+  setFiltersToDefault: () => Promise<void>;
+  setApiFilters: (filters: Partial<QueryParams>) => Promise<void>;
+  setResultsMode: (mode: ResultsMode) => Promise<void>;
+  setSortBy: (sortBy: SortBy) => Promise<void>;
+  setPropertySlug: (slug: string) => Promise<void>;
+  getResultsUrl: () => Promise<string | null>;
+  setResolvedQuestionnaireValues: (name: string, values: string[]) => Promise<void>;
+  handleTempFilterChange: <K extends keyof Filters>(key: K, value: Filters[K]) => Promise<void>;
+  commitTempFilterChange: <K extends keyof Filters>(key: K, defaultValue: Filters[K]) => Promise<void>;
+  handleFilterCommitIndexDB: (newFilters: Partial<Filters>) => Promise<void>;
+  commitAvailabilityChange: () => Promise<void>;
+  submitFilterUpdate: () => Promise<void>;
+  loadPersistedFilters: () => Promise<void>;
+
+  // Internal hydration
+  _hydrate: () => Promise<void>;
+  _initialize: () => Promise<void>;
+}
+
+export function createZustandAppStore(options?: {
+  onFilterUpdate?: (apiParams: QueryParams) => void;
+}) {
+  return (set: any, get: any): ZustandAppStoreState => {
+    // Helper to update local state after ORM operations
+    const syncState = async () => {
+      const ormState = await appStore.getFullState();
+      set({
+        data: ormState.data,
+        filters: ormState.filters,
+        tempFilters: ormState.tempFilters,
+        apiFilters: ormState.apiFilters,
+        resultsMode: ormState.resultsMode,
+        propertySlug: ormState.propertySlug,
+        resolvedQuestionnaireValues: ormState.resolvedQuestionnaireValues,
+        sortBy: ormState.sortBy,
+        filtersLoaded: ormState.filtersLoaded,
+      });
+    };
+
+    return {
+      // Initial state
+      data: {},
+      filters: {
+        availability: undefined,
+        bedrooms: undefined,
+        cost: undefined,
+        highlights: undefined,
+      },
+      tempFilters: {
+        availability: undefined,
+        bedrooms: undefined,
+        cost: undefined,
+        highlights: undefined,
+      },
+      apiFilters: {
+        limit: 10,
+        page: 1,
+      },
+      resultsMode: "all",
+      propertySlug: null,
+      resolvedQuestionnaireValues: {},
+      sortBy: "relevance",
+      filtersLoaded: false,
+
+      // Unit data actions
+      async setData(key, value) {
+        await appStore.setData(key, value);
+        const state = get();
+        set({ data: { ...state.data, [key]: value } });
+      },
+
+      async removeData(key) {
+        await appStore.removeData(key);
+        await syncState();
+      },
+
+      async clearData() {
+        await appStore.clearData();
+        set({ data: {} });
+      },
+
+      // Filter actions
+      async setFilters(filters) {
+        await appStore.setFilters(filters);
+        const state = get();
+        set({ filters: { ...state.filters, ...filters } });
+      },
+
+      async setTempFilters(filters) {
+        await appStore.setTempFilters(filters);
+        const state = get();
+        set({ tempFilters: { ...state.tempFilters, ...filters } });
+      },
+
+      async setFiltersToDefault() {
+        await appStore.setFiltersToDefault();
+        const defaultFilters = {
+          availability: undefined,
+          bedrooms: undefined,
+          cost: undefined,
+          highlights: undefined,
+        };
+        set({ filters: defaultFilters });
+      },
+
+      async setApiFilters(filters) {
+        await appStore.setApiFilters(filters);
+        const state = get();
+        set({ apiFilters: { ...state.apiFilters, ...filters } });
+      },
+
+      // Results and sorting actions
+      async setResultsMode(mode) {
+        await appStore.setResultsMode(mode);
+        set({ resultsMode: mode });
+      },
+
+      async setSortBy(sortBy) {
+        await appStore.setSortBy(sortBy);
+        set({ sortBy });
+      },
+
+      // Property actions
+      async setPropertySlug(slug) {
+        await appStore.setPropertySlug(slug);
+        set({ propertySlug: slug });
+      },
+
+      getResultsUrl: appStore.getResultsUrl.bind(appStore),
+
+      // Questionnaire actions
+      async setResolvedQuestionnaireValues(name, values) {
+        await appStore.setResolvedQuestionnaireValues(name, values);
+        const state = get();
+        set({
+          resolvedQuestionnaireValues: {
+            ...state.resolvedQuestionnaireValues,
+            [name]: values,
+          }
+        });
+      },
+
+      // Complex filter operations
+      async handleTempFilterChange(key, value) {
+        await appStore.handleTempFilterChange(key, value);
+        const state = get();
+        set({ tempFilters: { ...state.tempFilters, [key]: value } });
+      },
+
+      async commitTempFilterChange(key, defaultValue) {
+        await appStore.commitTempFilterChange(key, defaultValue);
+        await syncState();
+      },
+
+      async handleFilterCommitIndexDB(newFilters) {
+        await appStore.handleFilterCommitIndexDB(newFilters);
+        await syncState();
+      },
+
+      async commitAvailabilityChange() {
+        await appStore.commitAvailabilityChange();
+        await syncState();
+
+        // Notify consuming app of filter update if callback provided
+        if (options?.onFilterUpdate) {
+          const apiFilters = await appStore.getApiFilters();
+          options.onFilterUpdate(apiFilters);
+        }
+      },
+
+      async submitFilterUpdate() {
+        await appStore.submitFilterUpdate();
+        await syncState();
+
+        // Notify consuming app of filter update if callback provided
+        if (options?.onFilterUpdate) {
+          const apiFilters = await appStore.getApiFilters();
+          options.onFilterUpdate(apiFilters);
+        }
+      },
+
+      async loadPersistedFilters() {
+        await appStore.loadPersistedFilters();
+        set({ filtersLoaded: true });
+      },
+
+      // Internal methods
+      async _hydrate() {
+        await syncState();
+      },
+
+      async _initialize() {
+        await appStore.initialize();
+        await syncState();
+      },
+    };
+  };
+}
+
+// Export types for consuming apps
+export type { UnitData, Filters, QueryParams, ResultsMode, SortBy } from "../api/app";

package/src/adapters/zustand-unified.ts

@@ -0,0 +1,342 @@
+import { store, type UnifiedStoreData, type UnitData, type PropertyData, type Filters, type QueryParams, type ResultsMode, type SortBy, type TourContactData } from "../stores/unified";
+
+// Unified Zustand store interface
+export interface ZustandUnifiedStoreState {
+  // Property data
+  properties: Record<string, PropertyData>;
+  currentPropertyId: string | null;
+  currentPropertySlug: string | null;
+  hasPreviouslySearched: string[];
+
+  // App data
+  units: Record<string, UnitData>;
+  filters: Filters;
+  tempFilters: Filters;
+  apiFilters: QueryParams;
+  resultsMode: ResultsMode;
+  resolvedQuestionnaireValues: Record<string, string[]>;
+  sortBy: SortBy;
+  filtersLoaded: boolean;
+
+  // === PROPERTY OPERATIONS ===
+  initializeProperty: (propertyId: string, slug: string) => Promise<void>;
+  setCurrentProperty: (propertyId: string, slug?: string) => Promise<void>;
+  setCurrentPropertySlug: (slug: string) => Promise<void>;
+  setHasPreviouslySearched: (slug: string) => Promise<void>;
+  toggleFavorite: (unitId: string) => Promise<void>;
+  markUnitAsViewed: (unitId: string, slug: string) => Promise<void>;
+  setTourContactedOn: () => Promise<void>;
+  getTourContactedOn: () => Promise<string | null>;
+  setQuestionnaireResults: (results: unknown) => Promise<void>;
+  setTourContactData: (data: TourContactData) => Promise<void>;
+
+
+  // === FILTER OPERATIONS ===
+  setFilters: (filters: Partial<Filters>) => Promise<void>;
+  setTempFilters: (filters: Partial<Filters>) => Promise<void>;
+  setFiltersToDefault: () => Promise<void>;
+  setApiFilters: (filters: Partial<QueryParams>) => Promise<void>;
+  handleTempFilterChange: <K extends keyof Filters>(key: K, value: Filters[K]) => Promise<void>;
+  commitTempFilterChange: <K extends keyof Filters>(key: K, defaultValue: Filters[K]) => Promise<void>;
+  handleFilterCommitIndexDB: (newFilters: Partial<Filters>) => Promise<void>;
+  commitAvailabilityChange: () => Promise<void>;
+  submitFilterUpdate: () => Promise<void>;
+
+  // === RESULTS AND SORTING ===
+  setResultsMode: (mode: ResultsMode) => Promise<void>;
+  setSortBy: (sortBy: SortBy) => Promise<void>;
+
+  // === QUESTIONNAIRE ===
+  setResolvedQuestionnaireValues: (name: string, values: string[]) => Promise<void>;
+
+  // === UTILITY METHODS ===
+  getUnitState: (unitId: string) => {
+    isFavorite: boolean;
+    viewedDate: string;
+  };
+  getResultsUrl: () => Promise<string | null>;
+  getCurrentProperty: () => Promise<PropertyData | null>;
+  getPropertyData: (propertyId?: string) => Promise<PropertyData | null>;
+
+  // === LEGACY COMPATIBILITY ===
+  setData: (value: Record<string, PropertyData>) => Promise<void>;
+  setPropertySlug: (slug: string) => Promise<void>;
+  setPropertyId: (id: string) => Promise<void>;
+  removeData: (key: string) => Promise<void>;
+  clearData: () => Promise<void>;
+  loadPersistedFilters: () => Promise<void>;
+
+  // === INTERNAL ===
+  _hydrate: () => Promise<void>;
+  _initialize: () => Promise<void>;
+}
+
+export function createZustandUnifiedStore(options?: {
+  onFilterUpdate?: (apiParams: QueryParams) => void;
+}) {
+  return (set: any, get: any): ZustandUnifiedStoreState => {
+    // Helper to update local state after ORM operations
+    const syncState = async () => {
+      const ormState = await store.getFullState();
+      set({
+        properties: ormState.properties,
+        currentPropertyId: ormState.currentPropertyId,
+        currentPropertySlug: ormState.currentPropertySlug,
+        hasPreviouslySearched: ormState.hasPreviouslySearched,
+        filters: ormState.filters,
+        tempFilters: ormState.tempFilters,
+        apiFilters: ormState.apiFilters,
+        resultsMode: ormState.resultsMode,
+        resolvedQuestionnaireValues: ormState.resolvedQuestionnaireValues,
+        sortBy: ormState.sortBy,
+        filtersLoaded: ormState.filtersLoaded,
+      });
+    };
+
+    // Helper to notify of filter updates
+    const notifyFilterUpdate = async () => {
+      if (options?.onFilterUpdate) {
+        const apiFilters = (await store.getFullState()).apiFilters;
+        options.onFilterUpdate(apiFilters);
+      }
+    };
+
+    return {
+      // Initial state
+      properties: {},
+      currentPropertyId: null,
+      currentPropertySlug: null,
+      hasPreviouslySearched: [],
+      units: {},
+      filters: {
+        availability: undefined,
+        bedrooms: undefined,
+        cost: undefined,
+        highlights: undefined,
+      },
+      tempFilters: {
+        availability: undefined,
+        bedrooms: undefined,
+        cost: undefined,
+        highlights: undefined,
+      },
+      apiFilters: {
+        limit: 10,
+        page: 1,
+      },
+      resultsMode: "all",
+      resolvedQuestionnaireValues: {},
+      sortBy: "relevance",
+      filtersLoaded: false,
+
+      // === PROPERTY OPERATIONS ===
+      async initializeProperty(propertyId, slug) {
+        await store.initializeProperty(propertyId, slug);
+        await syncState();
+      },
+
+      async setCurrentProperty(propertyId, slug) {
+        await store.setCurrentProperty(propertyId, slug);
+        set({
+          currentPropertyId: propertyId,
+          ...(slug && { currentPropertySlug: slug })
+        });
+      },
+
+      async setCurrentPropertySlug(slug) {
+        await store.setCurrentPropertySlug(slug);
+        set({ currentPropertySlug: slug });
+      },
+
+      async setHasPreviouslySearched(slug) {
+        await store.setHasPreviouslySearched(slug);
+        await syncState();
+      },
+
+      async toggleFavorite(unitId) {
+        await store.toggleFavorite(unitId);
+        await syncState();
+      },
+
+      async markUnitAsViewed(unitId, slug) {
+        await store.markUnitAsViewed(unitId, slug);
+        await syncState();
+      },
+
+      async setTourContactedOn() {
+        await store.setTourContactedOn();
+        await syncState();
+      },
+
+      getTourContactedOn: store.getTourContactedOn.bind(store),
+
+      async setQuestionnaireResults(results) {
+        await store.setQuestionnaireResults(results);
+        await syncState();
+      },
+
+      async setTourContactData(data) {
+        await store.setTourContactData(data);
+        await syncState();
+      },
+
+
+      // === FILTER OPERATIONS ===
+      async setFilters(filters) {
+        await store.setFilters(filters);
+        const state = get();
+        set({ filters: { ...state.filters, ...filters } });
+      },
+
+      async setTempFilters(filters) {
+        await store.setTempFilters(filters);
+        const state = get();
+        set({ tempFilters: { ...state.tempFilters, ...filters } });
+      },
+
+      async setFiltersToDefault() {
+        await store.setFiltersToDefault();
+        const defaultFilters = {
+          availability: undefined,
+          bedrooms: undefined,
+          cost: undefined,
+          highlights: undefined,
+        };
+        set({ filters: defaultFilters });
+      },
+
+      async setApiFilters(filters) {
+        await store.setApiFilters(filters);
+        const state = get();
+        set({ apiFilters: { ...state.apiFilters, ...filters } });
+      },
+
+      async handleTempFilterChange(key, value) {
+        await store.handleTempFilterChange(key, value);
+        const state = get();
+        set({ tempFilters: { ...state.tempFilters, [key]: value } });
+      },
+
+      async commitTempFilterChange(key, defaultValue) {
+        await store.commitTempFilterChange(key, defaultValue);
+        await syncState();
+        await notifyFilterUpdate();
+      },
+
+      async handleFilterCommitIndexDB(newFilters) {
+        await store.handleFilterCommitIndexDB(newFilters);
+        await syncState();
+        await notifyFilterUpdate();
+      },
+
+      async commitAvailabilityChange() {
+        await store.commitAvailabilityChange();
+        await syncState();
+        await notifyFilterUpdate();
+      },
+
+      async submitFilterUpdate() {
+        await store.submitFilterUpdate();
+        await syncState();
+        await notifyFilterUpdate();
+      },
+
+      // === RESULTS AND SORTING ===
+      async setResultsMode(mode) {
+        await store.setResultsMode(mode);
+        set({ resultsMode: mode });
+      },
+
+      async setSortBy(sortBy) {
+        await store.setSortBy(sortBy);
+        set({ sortBy });
+      },
+
+      // === QUESTIONNAIRE ===
+      async setResolvedQuestionnaireValues(name, values) {
+        await store.setResolvedQuestionnaireValues(name, values);
+        const state = get();
+        set({
+          resolvedQuestionnaireValues: {
+            ...state.resolvedQuestionnaireValues,
+            [name]: values,
+          }
+        });
+      },
+
+      // === UTILITY METHODS ===
+      getUnitState(unitId: string) {
+        const state = get();
+        const property = state.currentPropertyId ? state.properties[state.currentPropertyId] : null;
+
+        return {
+          isFavorite: property?.favoritedUnits.includes(unitId) ?? false,
+          viewedDate:
+            property?.viewedUnits.find((u: any) => u.unitId === unitId)?.viewedDate ?? "",
+        };
+      },
+
+      getResultsUrl: store.getResultsUrl.bind(store),
+      getCurrentProperty: store.getCurrentProperty.bind(store),
+      getPropertyData: store.getPropertyData.bind(store),
+
+      // === LEGACY COMPATIBILITY ===
+      async setData(value) {
+        await store.setData(value);
+        set({ properties: value });
+      },
+
+      async setPropertySlug(slug) {
+        await store.setPropertySlug(slug);
+        set({ currentPropertySlug: slug });
+      },
+
+      async setPropertyId(id) {
+        await store.setPropertyId(id);
+        set({ currentPropertyId: id });
+      },
+
+      async removeData(key) {
+        await store.removeData(key);
+        await syncState();
+      },
+
+      async clearData() {
+        await store.clearData();
+        set({ properties: {} });
+      },
+
+      async loadPersistedFilters() {
+        await store.loadPersistedFilters();
+        set({ filtersLoaded: true });
+      },
+
+      // === INTERNAL ===
+      async _hydrate() {
+        await syncState();
+      },
+
+      async _initialize() {
+        await store.initialize();
+        await syncState();
+      },
+    };
+  };
+}
+
+// Helper hook factory for unit state
+export function createUseUnitState() {
+  return (useStore: any) => (unitId: string) =>
+    useStore((state: ZustandUnifiedStoreState) => state.getUnitState(unitId));
+}
+
+// Export types for consuming apps
+export type {
+  UnitData,
+  PropertyData,
+  Filters,
+  QueryParams,
+  ResultsMode,
+  SortBy,
+  TourContactData
+} from "../stores/unified";