@superbright/indexeddb-orm 0.1.1

package/src/adapters/zustand.ts

@@ -0,0 +1,142 @@
+import { propertyStore, type PropertyData, type TourContactData } from "../api/properties";
+
+// Zustand-compatible store creation helper
+export interface ZustandPropertyStoreState {
+  data: Record<string, PropertyData>;
+  propertySlug: string | null;
+  propertyId: string | null;
+  hasPreviouslySearched: string[];
+
+  // Async actions
+  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>;
+  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>;
+  initializeProperty: (propertyId: string, slug: string) => Promise<void>;
+
+  // Sync getters
+  getUnitState: (unitId: string) => {
+    isFavorite: boolean;
+    viewedDate: string;
+  };
+
+  // Internal hydration
+  _hydrate: () => Promise<void>;
+}
+
+export function createZustandPropertyStore() {
+  return (set: any, get: any): ZustandPropertyStoreState => {
+    // Helper to update local state after ORM operations
+    const syncState = async () => {
+      const ormState = await propertyStore.getFullState();
+      set({
+        data: ormState.data,
+        propertySlug: ormState.propertySlug,
+        propertyId: ormState.propertyId,
+        hasPreviouslySearched: ormState.hasPreviouslySearched,
+      });
+    };
+
+    return {
+      // Initial state
+      data: {},
+      propertySlug: null,
+      propertyId: null,
+      hasPreviouslySearched: [],
+
+      // Actions that modify state
+      async setData(value) {
+        await propertyStore.setData(value);
+        set({ data: value });
+      },
+
+      async setPropertySlug(slug) {
+        await propertyStore.setPropertySlug(slug);
+        set({ propertySlug: slug });
+      },
+
+      async setPropertyId(id) {
+        await propertyStore.setPropertyId(id);
+        set({ propertyId: id });
+      },
+
+      async removeData(key) {
+        await propertyStore.removeData(key);
+        await syncState();
+      },
+
+      async clearData() {
+        await propertyStore.clearData();
+        set({ data: {} });
+      },
+
+      async setHasPreviouslySearched(slug) {
+        await propertyStore.setHasPreviouslySearched(slug);
+        await syncState();
+      },
+
+      async toggleFavorite(unitId) {
+        await propertyStore.toggleFavorite(unitId);
+        await syncState();
+      },
+
+      async markUnitAsViewed(unitId, slug) {
+        await propertyStore.markUnitAsViewed(unitId, slug);
+        await syncState();
+      },
+
+      async setTourContactedOn() {
+        await propertyStore.setTourContactedOn();
+        await syncState();
+      },
+
+      getTourContactedOn: propertyStore.getTourContactedOn.bind(propertyStore),
+
+      async setQuestionnaireResults(results) {
+        await propertyStore.setQuestionnaireResults(results);
+        await syncState();
+      },
+
+      async setTourContactData(data) {
+        await propertyStore.setTourContactData(data);
+        await syncState();
+      },
+
+      async initializeProperty(propertyId, slug) {
+        await propertyStore.initializeProperty(propertyId, slug);
+        await syncState();
+      },
+
+      // Sync getter for unit state
+      getUnitState(unitId: string) {
+        const state = get();
+        const property = state.propertyId ? state.data[state.propertyId] : null;
+
+        return {
+          isFavorite: property?.favoritedUnits.includes(unitId) ?? false,
+          viewedDate:
+            property?.viewedUnits.find((u: any) => u.unitId === unitId)?.viewedDate ?? "",
+        };
+      },
+
+      // Internal hydration method
+      async _hydrate() {
+        await syncState();
+      },
+    };
+  };
+}
+
+// Helper hook factory for React apps
+export function createUseUnitState() {
+  return (useStore: any) => (unitId: string) =>
+    useStore((state: ZustandPropertyStoreState) => state.getUnitState(unitId));
+}

package/src/api/app.ts

@@ -0,0 +1,270 @@
+import { z } from "zod";
+import { kvGet, kvSet } from "../storage";
+
+// App-related schemas
+export const UnitDataSchema = z.object({
+  isFavorite: z.boolean().optional(),
+  viewedDate: z.string().optional(),
+});
+
+export const FiltersSchema = z.object({
+  availability: z.union([z.string(), z.array(z.string())]).nullable().optional(),
+  bedrooms: z.array(z.number()).nullable().optional(),
+  cost: z.number().nullable().optional(),
+  highlights: z.array(z.string()).optional(),
+});
+
+export const QueryParamsSchema = z.object({
+  limit: z.number().default(10),
+  page: z.number().default(1),
+  availability: z.array(z.string()).optional(),
+  bedrooms: z.array(z.number()).optional(),
+  cost: z.number().nullable().optional(),
+  highlights: z.array(z.string()).optional(),
+});
+
+export const AppStoreDataSchema = z.object({
+  data: z.record(UnitDataSchema),
+  filters: FiltersSchema,
+  tempFilters: FiltersSchema,
+  apiFilters: QueryParamsSchema,
+  resultsMode: z.enum(["all", "bestFit", "closestMatch", "favorites"]),
+  propertySlug: z.string().nullable(),
+  resolvedQuestionnaireValues: z.record(z.array(z.string())),
+  sortBy: z.enum(["relevance", "newest", "priceLowToHigh", "priceHighToLow"]),
+  filtersLoaded: z.boolean(),
+});
+
+export type UnitData = z.infer<typeof UnitDataSchema>;
+export type Filters = z.infer<typeof FiltersSchema>;
+export type QueryParams = z.infer<typeof QueryParamsSchema>;
+export type AppStoreData = z.infer<typeof AppStoreDataSchema>;
+export type ResultsMode = "all" | "bestFit" | "closestMatch" | "favorites";
+export type SortBy = "relevance" | "newest" | "priceLowToHigh" | "priceHighToLow";
+
+// Default values
+const defaultFilters: Filters = {
+  availability: undefined,
+  bedrooms: undefined,
+  cost: undefined,
+  highlights: undefined,
+};
+
+const defaultAppStoreData: AppStoreData = {
+  data: {},
+  filters: defaultFilters,
+  tempFilters: defaultFilters,
+  apiFilters: {
+    limit: 10,
+    page: 1,
+  },
+  resultsMode: "all",
+  propertySlug: null,
+  resolvedQuestionnaireValues: {},
+  sortBy: "relevance",
+  filtersLoaded: false,
+};
+
+// Core app store API
+export class AppStore {
+  private async getState(): Promise<AppStoreData> {
+    const state = await kvGet<AppStoreData>("app");
+    return state ?? defaultAppStoreData;
+  }
+
+  private async setState(updater: (state: AppStoreData) => AppStoreData): Promise<void> {
+    const currentState = await this.getState();
+    const newState = updater(currentState);
+    await kvSet("app", newState);
+  }
+
+  // Unit data operations
+  async setData(key: string, value: UnitData): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      data: { ...state.data, [key]: value }
+    }));
+  }
+
+  async removeData(key: string): Promise<void> {
+    await this.setState(state => {
+      const { [key]: removed, ...rest } = state.data;
+      return { ...state, data: rest };
+    });
+  }
+
+  async clearData(): Promise<void> {
+    await this.setState(state => ({ ...state, data: {} }));
+  }
+
+  // Filter operations
+  async setFilters(filters: Partial<Filters>): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      filters: { ...state.filters, ...filters }
+    }));
+  }
+
+  async setTempFilters(filters: Partial<Filters>): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      tempFilters: { ...state.tempFilters, ...filters }
+    }));
+  }
+
+  async setFiltersToDefault(): Promise<void> {
+    await this.setState(state => ({ ...state, filters: defaultFilters }));
+  }
+
+  async setApiFilters(filters: Partial<QueryParams>): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      apiFilters: { ...state.apiFilters, ...filters }
+    }));
+  }
+
+  // Results and sorting
+  async setResultsMode(mode: ResultsMode): Promise<void> {
+    await this.setState(state => ({ ...state, resultsMode: mode }));
+  }
+
+  async setSortBy(sortBy: SortBy): Promise<void> {
+    await this.setState(state => ({ ...state, sortBy }));
+  }
+
+  // Property operations
+  async setPropertySlug(slug: string): Promise<void> {
+    await this.setState(state => ({ ...state, propertySlug: slug }));
+  }
+
+  async getResultsUrl(): Promise<string | null> {
+    const state = await this.getState();
+    return state.propertySlug ? `/${state.propertySlug}/results` : null;
+  }
+
+  // Questionnaire values
+  async setResolvedQuestionnaireValues(name: string, values: string[]): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      resolvedQuestionnaireValues: {
+        ...state.resolvedQuestionnaireValues,
+        [name]: values
+      }
+    }));
+  }
+
+  // Complex filter operations
+  async handleTempFilterChange<K extends keyof Filters>(
+    key: K,
+    value: Filters[K]
+  ): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      tempFilters: { ...state.tempFilters, [key]: value }
+    }));
+  }
+
+  async commitTempFilterChange<K extends keyof Filters>(
+    key: K,
+    defaultValue: Filters[K]
+  ): Promise<void> {
+    const state = await this.getState();
+    const value = state.tempFilters[key] ?? defaultValue;
+
+    await this.handleTempFilterChange(key, value);
+    await this.submitFilterUpdate();
+  }
+
+  async handleFilterCommitIndexDB(newFilters: Partial<Filters>): Promise<void> {
+    await this.setState(state => {
+      const apiParams: QueryParams = {
+        ...state.apiFilters,
+        availability: (newFilters.availability as string[]) || [],
+        bedrooms: newFilters.bedrooms || [],
+        cost: newFilters.cost || null,
+        highlights: newFilters.highlights || [],
+      };
+      return {
+        ...state,
+        filters: { ...state.filters, ...newFilters },
+        apiFilters: apiParams,
+      };
+    });
+  }
+
+  async commitAvailabilityChange(): Promise<void> {
+    await this.submitFilterUpdate();
+  }
+
+  async submitFilterUpdate(): Promise<void> {
+    await this.setState(state => {
+      try {
+        const apiParams: QueryParams = {
+          ...state.apiFilters,
+          availability: (state.filters.availability as string[]) || [],
+          bedrooms: state.filters.bedrooms || [],
+          cost: state.filters.cost || null,
+          highlights: state.filters.highlights || [],
+        };
+
+        // Note: updateParams function call would need to be handled in consuming app
+        // You might want to emit an event or use a callback for this
+
+        return {
+          ...state,
+          apiFilters: apiParams,
+        };
+      } catch (error) {
+        console.error("Error submitting filter update:", error);
+        return state;
+      }
+    });
+  }
+
+  // Persistence operations
+  async loadPersistedFilters(): Promise<void> {
+    // This method is now redundant since we're always loading from IndexedDB
+    // But we'll keep it for compatibility and mark filters as loaded
+    await this.setState(state => ({ ...state, filtersLoaded: true }));
+  }
+
+  // Utility methods
+  async getUnitData(unitId: string): Promise<UnitData | null> {
+    const state = await this.getState();
+    return state.data[unitId] ?? null;
+  }
+
+  async getFilters(): Promise<Filters> {
+    const state = await this.getState();
+    return state.filters;
+  }
+
+  async getTempFilters(): Promise<Filters> {
+    const state = await this.getState();
+    return state.tempFilters;
+  }
+
+  async getApiFilters(): Promise<QueryParams> {
+    const state = await this.getState();
+    return state.apiFilters;
+  }
+
+  async getFullState(): Promise<AppStoreData> {
+    return this.getState();
+  }
+
+  // Initialize with default values if needed
+  async initialize(): Promise<void> {
+    const state = await this.getState();
+    if (Object.keys(state.data).length === 0 && !state.filtersLoaded) {
+      await this.setState(state => ({
+        ...defaultAppStoreData,
+        ...state,
+        filtersLoaded: true
+      }));
+    }
+  }
+}
+
+// Export singleton instance
+export const appStore = new AppStore();

package/src/api/favorites.ts

@@ -0,0 +1,64 @@
+// src/api/favourites.ts
+import { getDB } from "../db";
+import { ensureUser } from "./users";
+import { FavoritesSchema } from "../schema";
+
+const keyFor = (userId: string, propertyId: string) =>
+  `favorites:${userId}:${propertyId}`;
+
+export async function getFavoritedUnitsForProperty(
+  propertyId: string | number,
+): Promise<string[]> {
+  const db = await getDB();
+  const { uuid } = await ensureUser();
+  const key = keyFor(uuid, String(propertyId));
+  const row = await db.kv.get(key);
+  const parsed = row ? FavoritesSchema.safeParse(row.value) : null;
+  return parsed?.success ? parsed.data.unitIds : [];
+}
+
+export async function setFavoriteUnit(
+  propertyId: string | number,
+  unitId: string,
+  on: boolean,
+): Promise<string[]> {
+  const db = await getDB();
+  const { uuid } = await ensureUser();
+  const key = keyFor(uuid, String(propertyId));
+
+  return db.transaction("rw", db.kv, async () => {
+    const row = await db.kv.get(key);
+    const current =
+      row && FavoritesSchema.safeParse(row.value).success
+        ? (row!.value as any)
+        : { unitIds: [] as string[], updatedAt: new Date().toISOString() };
+
+    const nextSet = new Set<string>(current.unitIds);
+    on ? nextSet.add(unitId) : nextSet.delete(unitId);
+
+    const next = {
+      unitIds: [...nextSet],
+      updatedAt: new Date().toISOString(),
+    };
+    const validated = FavoritesSchema.parse(next);
+    await db.kv.put({ key, value: validated });
+    return validated.unitIds;
+  });
+}
+
+export async function toggleFavoriteUnit(
+  propertyId: string | number,
+  unitId: string,
+): Promise<string[]> {
+  const current = await getFavoritedUnitsForProperty(propertyId);
+  const on = !current.includes(unitId);
+  return setFavoriteUnit(propertyId, unitId, on);
+}
+
+export async function isUnitFavorited(
+  propertyId: string | number,
+  unitId: string,
+): Promise<boolean> {
+  const list = await getFavoritedUnitsForProperty(propertyId);
+  return list.includes(unitId);
+}