@superbright/indexeddb-orm 0.1.1 → 0.1.3

package/src/adapters/zustand.ts

@@ -1,142 +0,0 @@
-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

@@ -1,270 +0,0 @@
-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

@@ -1,64 +0,0 @@
-// 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);
-}