@superbright/indexeddb-orm 0.1.1

package/src/storage.ts

@@ -0,0 +1,71 @@
+import { getDB } from "./db";
+
+export interface AsyncStringStorage {
+  getItem(name: string): Promise<string | null>;
+  setItem(name: string, value: string): Promise<void>;
+  removeItem(name: string): Promise<void>;
+}
+
+type storeKeys = "property" | "user" | "app";
+
+// Generic typed KV helpers (store raw objects in the ORM's kv table)
+export async function kvGet<T>(key: storeKeys): Promise<T | null> {
+  const db = await getDB();
+  const row = await db.kv.get(key);
+  return (row?.value as T | undefined) ?? null;
+}
+export async function kvSet<T>(key: storeKeys, value: T): Promise<void> {
+  const db = await getDB();
+  await db.kv.put({ key, value });
+}
+export async function kvRemove(key: storeKeys): Promise<void> {
+  const db = await getDB();
+  await db.kv.delete(key);
+}
+
+export function createORMStringStorage(opts?: {
+  prefix?: string;
+  fallbackToMemory?: boolean;
+}): AsyncStringStorage {
+  const mem = new Map<string, string>(); // optional fallback
+  const prefix = opts?.prefix ?? "";
+
+  const toKey = (name: string) => `${prefix}${name}`;
+
+  return {
+    async getItem(name) {
+      try {
+        const db = await getDB();
+        const row = await db.kv.get(toKey(name));
+        return row ? JSON.stringify(row.value) : null;
+      } catch (e) {
+        if (opts?.fallbackToMemory) return mem.get(toKey(name)) ?? null;
+        throw e;
+      }
+    },
+    async setItem(name, value) {
+      try {
+        const db = await getDB();
+        await db.kv.put({ key: toKey(name), value: JSON.parse(value) });
+      } catch (e) {
+        if (opts?.fallbackToMemory) {
+          mem.set(toKey(name), value);
+          return;
+        }
+        throw e;
+      }
+    },
+    async removeItem(name) {
+      try {
+        const db = await getDB();
+        await db.kv.delete(toKey(name));
+      } catch (e) {
+        if (opts?.fallbackToMemory) {
+          mem.delete(toKey(name));
+          return;
+        }
+        throw e;
+      }
+    },
+  };
+}

package/src/stores/property.ts

@@ -0,0 +1,133 @@
+import { propertyStore, type PropertyData, type TourContactData } from "../api/properties";
+
+// Zustand-compatible interface for the property store
+export interface PropertyStoreInterface {
+  data: Record<string, PropertyData>;
+  propertySlug: string | null;
+  propertyId: string | null;
+  hasPreviouslySearched: string[];
+
+  // Async methods
+  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>;
+
+  // Utility methods
+  getUnitState: (unitId: string) => Promise<{
+    isFavorite: boolean;
+    viewedDate: string;
+  }>;
+  getPropertyData: (propertyId?: string) => Promise<PropertyData | null>;
+  initializeProperty: (propertyId: string, slug: string) => Promise<void>;
+
+  // State hydration
+  hydrate: () => Promise<void>;
+}
+
+// Factory function to create a property store instance
+export function createPropertyStore(): PropertyStoreInterface {
+  let currentState = {
+    data: {} as Record<string, PropertyData>,
+    propertySlug: null as string | null,
+    propertyId: null as string | null,
+    hasPreviouslySearched: [] as string[],
+  };
+
+  const store: PropertyStoreInterface = {
+    get data() { return currentState.data; },
+    get propertySlug() { return currentState.propertySlug; },
+    get propertyId() { return currentState.propertyId; },
+    get hasPreviouslySearched() { return currentState.hasPreviouslySearched; },
+
+    async hydrate() {
+      const state = await propertyStore.getFullState();
+      currentState = state;
+    },
+
+    async setData(value) {
+      await propertyStore.setData(value);
+      currentState.data = value;
+    },
+
+    async setPropertySlug(slug) {
+      await propertyStore.setPropertySlug(slug);
+      currentState.propertySlug = slug;
+    },
+
+    async setPropertyId(id) {
+      await propertyStore.setPropertyId(id);
+      currentState.propertyId = id;
+    },
+
+    async removeData(key) {
+      await propertyStore.removeData(key);
+      const { [key]: removed, ...rest } = currentState.data;
+      currentState.data = rest;
+    },
+
+    async clearData() {
+      await propertyStore.clearData();
+      currentState.data = {};
+    },
+
+    async setHasPreviouslySearched(slug) {
+      await propertyStore.setHasPreviouslySearched(slug);
+      currentState.hasPreviouslySearched = Array.from(
+        new Set([...currentState.hasPreviouslySearched, slug])
+      );
+    },
+
+    async toggleFavorite(unitId) {
+      await propertyStore.toggleFavorite(unitId);
+      // Refresh state after update
+      await store.hydrate();
+    },
+
+    async markUnitAsViewed(unitId, slug) {
+      await propertyStore.markUnitAsViewed(unitId, slug);
+      // Refresh state after update
+      await store.hydrate();
+    },
+
+    async setTourContactedOn() {
+      await propertyStore.setTourContactedOn();
+      // Refresh state after update
+      await store.hydrate();
+    },
+
+    getTourContactedOn: propertyStore.getTourContactedOn.bind(propertyStore),
+
+    async setQuestionnaireResults(results) {
+      await propertyStore.setQuestionnaireResults(results);
+      // Refresh state after update
+      await store.hydrate();
+    },
+
+    async setTourContactData(data) {
+      await propertyStore.setTourContactData(data);
+      // Refresh state after update
+      await store.hydrate();
+    },
+
+    getUnitState: propertyStore.getUnitState.bind(propertyStore),
+    getPropertyData: propertyStore.getPropertyData.bind(propertyStore),
+    initializeProperty: async (propertyId, slug) => {
+      await propertyStore.initializeProperty(propertyId, slug);
+      await store.hydrate();
+    },
+  };
+
+  return store;
+}
+
+// Singleton instance for convenience
+export const defaultPropertyStore = createPropertyStore();

package/src/stores/unified.ts

@@ -0,0 +1,507 @@
+import { z } from "zod";
+import { kvGet, kvSet } from "../storage";
+
+// Combined store schemas
+export const UnitDataSchema = z.object({
+  isFavorite: z.boolean().optional(),
+  viewedDate: z.string().optional(),
+});
+
+export const ViewedUnitSchema = z.object({
+  unitId: z.string(),
+  viewedDate: z.string(),
+});
+
+export const TourContactDataSchema = z.object({
+  timezone: z.string(),
+  favouriteUnits: z.array(z.string()).optional(),
+  preferences: z.record(z.unknown()),
+});
+
+export const PropertyDataSchema = z.object({
+  id: z.string(),
+  slug: z.string(),
+  favoritedUnits: z.array(z.string()),
+  tourContactedOn: z.string().nullable(),
+  viewedUnits: z.array(ViewedUnitSchema),
+  questionnaireResults: z.unknown().nullable().optional(),
+  tourContactData: TourContactDataSchema.nullable().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 UnifiedStoreDataSchema = z.object({
+  // Property-related data
+  properties: z.record(PropertyDataSchema),
+  currentPropertyId: z.string().nullable(),
+  currentPropertySlug: z.string().nullable(),
+  hasPreviouslySearched: z.array(z.string()),
+
+  // App-level data
+  filters: FiltersSchema,
+  tempFilters: FiltersSchema,
+  apiFilters: QueryParamsSchema,
+  resultsMode: z.enum(["all", "bestFit", "closestMatch", "favorites"]),
+  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 ViewedUnit = z.infer<typeof ViewedUnitSchema>;
+export type TourContactData = z.infer<typeof TourContactDataSchema>;
+export type PropertyData = z.infer<typeof PropertyDataSchema>;
+export type Filters = z.infer<typeof FiltersSchema>;
+export type QueryParams = z.infer<typeof QueryParamsSchema>;
+export type UnifiedStoreData = z.infer<typeof UnifiedStoreDataSchema>;
+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 defaultUnifiedStoreData: UnifiedStoreData = {
+  // Property data
+  properties: {},
+  currentPropertyId: null,
+  currentPropertySlug: null,
+  hasPreviouslySearched: [],
+
+  // App data
+  filters: defaultFilters,
+  tempFilters: defaultFilters,
+  apiFilters: {
+    limit: 10,
+    page: 1,
+  },
+  resultsMode: "all",
+  resolvedQuestionnaireValues: {},
+  sortBy: "relevance",
+  filtersLoaded: false,
+};
+
+// Unified store class
+export class UnifiedStore {
+  private async getState(): Promise<UnifiedStoreData> {
+    const state = await kvGet<UnifiedStoreData>("app");
+    if (!state) {
+      return defaultUnifiedStoreData;
+    }
+
+    // Ensure all required fields exist (defensive programming)
+    return {
+      ...defaultUnifiedStoreData,
+      ...state,
+      properties: state.properties ?? {},
+    };
+  }
+
+  private async setState(updater: (state: UnifiedStoreData) => UnifiedStoreData): Promise<void> {
+    const currentState = await this.getState();
+    const newState = updater(currentState);
+    await kvSet("app", newState);
+  }
+
+  // === PROPERTY OPERATIONS ===
+
+  async initializeProperty(propertyId: string, slug: string): Promise<void> {
+    await this.setState(state => {
+      if (state.properties && state.properties[propertyId]) {
+        return {
+          ...state,
+          currentPropertyId: propertyId,
+          currentPropertySlug: slug
+        };
+      }
+
+      return {
+        ...state,
+        currentPropertyId: propertyId,
+        currentPropertySlug: slug,
+        properties: {
+          ...state.properties,
+          [propertyId]: {
+            id: propertyId,
+            slug,
+            favoritedUnits: [],
+            tourContactedOn: null,
+            viewedUnits: [],
+            questionnaireResults: null,
+            tourContactData: null,
+          },
+        },
+      };
+    });
+  }
+
+  async setCurrentProperty(propertyId: string, slug?: string): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      currentPropertyId: propertyId,
+      currentPropertySlug: slug || state.currentPropertySlug,
+    }));
+  }
+
+  async setCurrentPropertySlug(slug: string): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      currentPropertySlug: slug
+    }));
+  }
+
+  async setHasPreviouslySearched(slug: string): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      hasPreviouslySearched: Array.from(
+        new Set([...state.hasPreviouslySearched, slug])
+      ),
+    }));
+  }
+
+  async toggleFavorite(unitId: string): Promise<void> {
+    await this.setState(state => {
+      const propertyId = state.currentPropertyId;
+      if (!propertyId) return state;
+
+      const property = state.properties[propertyId];
+      if (!property) return state;
+
+      const isFavorited = property.favoritedUnits.includes(unitId);
+      const updatedFavoritedUnits = isFavorited
+        ? property.favoritedUnits.filter((id) => id !== unitId)
+        : [...property.favoritedUnits, unitId];
+
+      return {
+        ...state,
+        properties: {
+          ...state.properties,
+          [propertyId]: {
+            ...property,
+            favoritedUnits: updatedFavoritedUnits,
+          },
+        },
+      };
+    });
+  }
+
+  async markUnitAsViewed(unitId: string, slug: string): Promise<void> {
+    const today = new Date();
+    const formattedDate = `${String(today.getMonth() + 1).padStart(
+      2,
+      "0"
+    )}/${String(today.getDate()).padStart(2, "0")}`;
+
+    await this.setState(state => {
+      const propertyId = state.currentPropertyId;
+      if (!propertyId) return state;
+
+      const property = state.properties[propertyId];
+      if (!property) return state;
+
+      const updatedViewedUnits = [
+        ...property.viewedUnits.filter((u) => u.unitId !== unitId),
+        { unitId, viewedDate: formattedDate },
+      ];
+
+      return {
+        ...state,
+        properties: {
+          ...state.properties,
+          [propertyId]: {
+            ...property,
+            viewedUnits: updatedViewedUnits,
+          },
+        },
+      };
+    });
+
+    if (typeof window !== 'undefined') {
+      window.open(`//${slug}`, "_blank");
+    }
+  }
+
+  async setTourContactedOn(): Promise<void> {
+    await this.setState(state => {
+      const propertyId = state.currentPropertyId;
+      if (!propertyId) return state;
+
+      const property = state.properties[propertyId];
+      if (!property) return state;
+
+      return {
+        ...state,
+        properties: {
+          ...state.properties,
+          [propertyId]: {
+            ...property,
+            tourContactedOn: new Date().toISOString(),
+          },
+        },
+      };
+    });
+  }
+
+  async getTourContactedOn(): Promise<string | null> {
+    const state = await this.getState();
+    const propertyId = state.currentPropertyId;
+    if (!propertyId) return null;
+
+    return state.properties[propertyId]?.tourContactedOn ?? null;
+  }
+
+  async setQuestionnaireResults(results: unknown): Promise<void> {
+    await this.setState(state => {
+      const propertyId = state.currentPropertyId;
+      if (!propertyId) return state;
+
+      const property = state.properties[propertyId];
+      if (!property) return state;
+
+      return {
+        ...state,
+        properties: {
+          ...state.properties,
+          [propertyId]: {
+            ...property,
+            questionnaireResults: results,
+          },
+        },
+      };
+    });
+  }
+
+  async setTourContactData(data: TourContactData): Promise<void> {
+    await this.setState(state => {
+      const propertyId = state.currentPropertyId;
+      if (!propertyId) return state;
+
+      const property = state.properties[propertyId];
+      if (!property) return state;
+
+      return {
+        ...state,
+        properties: {
+          ...state.properties,
+          [propertyId]: {
+            ...property,
+            tourContactData: 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 }
+    }));
+  }
+
+  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 => {
+      const apiParams: QueryParams = {
+        ...state.apiFilters,
+        availability: (state.filters.availability as string[]) || [],
+        bedrooms: state.filters.bedrooms || [],
+        cost: state.filters.cost || null,
+        highlights: state.filters.highlights || [],
+      };
+
+      return {
+        ...state,
+        apiFilters: apiParams,
+      };
+    });
+  }
+
+  // === 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 }));
+  }
+
+  // === QUESTIONNAIRE ===
+
+  async setResolvedQuestionnaireValues(name: string, values: string[]): Promise<void> {
+    await this.setState(state => ({
+      ...state,
+      resolvedQuestionnaireValues: {
+        ...state.resolvedQuestionnaireValues,
+        [name]: values
+      }
+    }));
+  }
+
+  // === UTILITY METHODS ===
+
+  async getUnitState(unitId: string): Promise<{
+    isFavorite: boolean;
+    viewedDate: string;
+  }> {
+    const state = await this.getState();
+    const property = state.currentPropertyId ? state.properties[state.currentPropertyId] : null;
+
+    return {
+      isFavorite: property?.favoritedUnits.includes(unitId) ?? false,
+      viewedDate:
+        property?.viewedUnits.find((u) => u.unitId === unitId)?.viewedDate ?? "",
+    };
+  }
+
+  async getResultsUrl(): Promise<string | null> {
+    const state = await this.getState();
+    return state.currentPropertySlug ? `/${state.currentPropertySlug}/results` : null;
+  }
+
+  async getCurrentProperty(): Promise<PropertyData | null> {
+    const state = await this.getState();
+    return state.currentPropertyId ? state.properties[state.currentPropertyId] ?? null : null;
+  }
+
+  async getPropertyData(propertyId?: string): Promise<PropertyData | null> {
+    const state = await this.getState();
+    const id = propertyId ?? state.currentPropertyId;
+    return id ? state.properties[id] ?? null : null;
+  }
+
+  async getFullState(): Promise<UnifiedStoreData> {
+    return this.getState();
+  }
+
+  async initialize(): Promise<void> {
+    const state = await this.getState();
+    if (Object.keys(state.properties).length === 0 && !state.filtersLoaded) {
+      await this.setState(state => ({
+        ...defaultUnifiedStoreData,
+        ...state,
+        filtersLoaded: true
+      }));
+    }
+  }
+
+  async loadPersistedFilters(): Promise<void> {
+    // Mark filters as loaded since we're always loading from IndexedDB
+    await this.setState(state => ({ ...state, filtersLoaded: true }));
+  }
+
+  // === LEGACY COMPATIBILITY METHODS ===
+
+  // Property store compatibility
+  async setData(value: Record<string, PropertyData>): Promise<void> {
+    await this.setState(state => ({ ...state, properties: value }));
+  }
+
+  async setPropertySlug(slug: string): Promise<void> {
+    await this.setCurrentPropertySlug(slug);
+  }
+
+  async setPropertyId(id: string): Promise<void> {
+    await this.setCurrentProperty(id);
+  }
+
+  async removeData(key: string): Promise<void> {
+    await this.setState(state => {
+      const { [key]: removed, ...rest } = state.properties;
+      return { ...state, properties: rest };
+    });
+  }
+
+  async clearData(): Promise<void> {
+    await this.setState(state => ({ ...state, properties: {} }));
+  }
+}
+
+// Export singleton instance
+export const store = new UnifiedStore();