Initial commit - Route Commerce platform

2026-06-01 19:40:55 +00:00
commit 53a9671461
617 changed files with 106132 additions and 0 deletions
@@ -0,0 +1,264 @@
+import { createClient, type SupabaseClient } from "@supabase/supabase-js";
+import { getMockTableData } from "./mock-data";
+
+const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+
+// Auto-enable mock mode when no Supabase URL is configured (demo/deployment without backend)
+const useMockData = process.env.NEXT_PUBLIC_USE_MOCK_DATA === "true" || !supabaseUrl || !supabaseUrl.includes("supabase.co");
+
+// Mock query builder that supports all common Supabase methods
+class MockQueryBuilder {
+  private data: unknown[];
+  private tableName: string;
+  private filters: { column: string; value: unknown; op: string }[] = [];
+  private selectColumns: string = "*";
+  private orderColumn?: string;
+  private orderDirection?: "asc" | "desc";
+  private limitValue?: number;
+
+  constructor(tableName: string) {
+    this.tableName = tableName;
+    this.data = [...(getMockTableData(tableName) || [])];
+  }
+
+  select(columns: string = "*") {
+    this.selectColumns = columns;
+    return this;
+  }
+
+  eq(column: string, value: unknown) {
+    this.filters.push({ column, value, op: "eq" });
+    return this;
+  }
+
+  neq(column: string, value: unknown) {
+    this.filters.push({ column, value, op: "neq" });
+    return this;
+  }
+
+  gt(column: string, value: unknown) {
+    this.filters.push({ column, value, op: "gt" });
+    return this;
+  }
+
+  gte(column: string, value: unknown) {
+    this.filters.push({ column, value, op: "gte" });
+    return this;
+  }
+
+  lt(column: string, value: unknown) {
+    this.filters.push({ column, value, op: "lt" });
+    return this;
+  }
+
+  lte(column: string, value: unknown) {
+    this.filters.push({ column, value, op: "lte" });
+    return this;
+  }
+
+  is(column: string, value: unknown) {
+    this.filters.push({ column, value, op: "is" });
+    return this;
+  }
+
+  like(column: string, value: string) {
+    this.filters.push({ column, value, op: "like" });
+    return this;
+  }
+
+  ilike(column: string, value: string) {
+    this.filters.push({ column, value, op: "ilike" });
+    return this;
+  }
+
+  in(column: string, values: unknown[]) {
+    this.filters.push({ column, value: values, op: "in" });
+    return this;
+  }
+
+  order(column: string, options?: { ascending?: boolean; nullsFirst?: boolean }) {
+    this.orderColumn = column;
+    this.orderDirection = options?.ascending === false ? "desc" : "asc";
+    return this;
+  }
+
+  limit(count: number) {
+    this.limitValue = count;
+    return this;
+  }
+
+  range(min: number, max: number) {
+    // For pagination mock
+    return this;
+  }
+
+  single() {
+    return this.executeSingle();
+  }
+
+  then(resolve: (value: unknown) => void, _reject?: (reason?: unknown) => void) {
+    const result = this.execute();
+    resolve(result);
+  }
+
+  async executeSingle() {
+    const result = this.execute();
+    if (result.data && Array.isArray(result.data) && result.data.length > 0) {
+      return { data: result.data[0], error: null };
+    }
+    return { data: null, error: null };
+  }
+
+  execute() {
+    let filtered = [...this.data];
+
+    // Apply filters
+    for (const filter of this.filters) {
+      filtered = filtered.filter((row: any) => {
+        const rowValue = row[filter.column];
+        switch (filter.op) {
+          case "eq":
+            return rowValue === filter.value;
+          case "neq":
+            return rowValue !== filter.value;
+          case "gt":
+            return (rowValue as number) > (filter.value as number);
+          case "gte":
+            return (rowValue as number) >= (filter.value as number);
+          case "lt":
+            return (rowValue as number) < (filter.value as number);
+          case "lte":
+            return (rowValue as number) <= (filter.value as number);
+          case "is":
+            if (filter.value === null) return rowValue === null;
+            if (filter.value === undefined) return rowValue === undefined;
+            return rowValue === filter.value;
+          case "like":
+            return typeof rowValue === "string" && rowValue.includes((filter.value as string).replace(/%/g, ""));
+          case "ilike":
+            return typeof rowValue === "string" && rowValue.toLowerCase().includes((filter.value as string).replace(/%/g, "").toLowerCase());
+          case "in":
+            return Array.isArray(filter.value) && filter.value.includes(rowValue);
+          default:
+            return true;
+        }
+      });
+    }
+
+    // Apply ordering
+    if (this.orderColumn) {
+      filtered.sort((a: any, b: any) => {
+        const aVal = a[this.orderColumn!];
+        const bVal = b[this.orderColumn!];
+        if (aVal < bVal) return this.orderDirection === "desc" ? 1 : -1;
+        if (aVal > bVal) return this.orderDirection === "desc" ? -1 : 1;
+        return 0;
+      });
+    }
+
+    // Apply limit
+    if (this.limitValue !== undefined) {
+      filtered = filtered.slice(0, this.limitValue);
+    }
+
+    return { data: filtered, error: null };
+  }
+}
+
+// Mock insert/update/delete builders
+class MockMutationBuilder {
+  private tableName: string;
+  private data: Record<string, unknown> | Record<string, unknown>[];
+
+  constructor(tableName: string, data: Record<string, unknown> | Record<string, unknown>[]) {
+    this.tableName = tableName;
+    this.data = data;
+  }
+
+  select() {
+    return new MockQueryBuilder(this.tableName);
+  }
+
+  then(resolve: (value: unknown) => void) {
+    const items = Array.isArray(this.data) ? this.data : [this.data];
+    const returning = items.map((item, i) => ({
+      ...item,
+      id: item.id || `generated-${Date.now()}-${i}`,
+    }));
+    resolve({ data: returning, error: null });
+  }
+}
+
+// Mock storage builder
+class MockStorageBuilder {
+  from(bucket: string) {
+    return {
+      upload: async (path: string, _file: unknown) => {
+        return { data: { path }, error: null };
+      },
+      download: async (path: string) => {
+        return { data: new Blob(), error: null };
+      },
+      remove: async (paths: string[]) => {
+        return { data: { paths }, error: null };
+      },
+      list: async () => {
+        return { data: [], error: null };
+      },
+    };
+  }
+}
+
+// Create mock client
+function createMockClient() {
+  return {
+    from: (table: string) => new MockQueryBuilder(table),
+    insert: (data: Record<string, unknown> | Record<string, unknown>[]) => new MockMutationBuilder("unknown", data),
+    update: (data: Record<string, unknown>) => new MockMutationBuilder("unknown", data),
+    delete: () => ({
+      eq: () => ({ then: (resolve: (value: unknown) => void) => resolve({ data: null, error: null }) }),
+      in: () => ({ then: (resolve: (value: unknown) => void) => resolve({ data: null, error: null }) }),
+    }),
+    storage: new MockStorageBuilder(),
+    auth: {
+      getSession: async () => ({ data: { session: null }, error: null }),
+      getUser: async () => ({ data: { user: null }, error: null }),
+      signInWithPassword: async () => ({ data: { user: null, session: null }, error: null }),
+      signOut: async () => ({ error: null }),
+      onAuthStateChange: () => ({ data: { subscription: { unsubscribe: () => {} } } }),
+    },
+    channel: () => ({
+      on: () => ({ subscribe: () => ({}) }),
+      subscribe: () => ({}),
+    }),
+  };
+}
+
+// Real Supabase client creation
+function getSupabase(): SupabaseClient {
+  if (!supabaseUrl || !supabaseAnonKey) {
+    throw new Error(
+      `Missing Supabase env vars: ${[!supabaseUrl && "NEXT_PUBLIC_SUPABASE_URL", !supabaseAnonKey && "NEXT_PUBLIC_SUPABASE_ANON_KEY"].filter(Boolean).join(", ")}. ` +
+      "Check Vercel environment variables for Production environment. " +
+      "Node env: " + (process.env.NODE_ENV ?? "unknown")
+    );
+  }
+  return createClient(supabaseUrl, supabaseAnonKey);
+}
+
+// Create proxy that routes to real or mock client
+let realSupabase: SupabaseClient | null = null;
+if (!useMockData) {
+  try {
+    realSupabase = getSupabase();
+  } catch {
+    // Will use mock below
+  }
+}
+
+export const supabase: SupabaseClient = useMockData || !realSupabase
+  ? createMockClient() as unknown as SupabaseClient
+  : realSupabase;
+
+export { supabaseUrl, supabaseAnonKey, useMockData };