@pol-studios/ui 1.0.0

package/dist/adapters/index.js

@@ -0,0 +1,359 @@
+"use client";
+
+// src/adapters/tanstack-router-adapter.ts
+import React, { useMemo } from "react";
+import {
+  useNavigate as useTanStackNavigate,
+  useLocation as useTanStackLocation,
+  useParams as useTanStackParams,
+  useRouter,
+  Link as TanStackLink
+} from "@tanstack/react-router";
+function TanStackLinkWrapper({ to, params, children, className, onClick }) {
+  const linkProps = {
+    to,
+    params,
+    className,
+    onClick,
+    children
+  };
+  return React.createElement(TanStackLink, linkProps);
+}
+function createTanStackRouterAdapter(navigateFn) {
+  return {
+    navigate: navigateFn ?? (() => {
+      console.warn("Navigate called on adapter created outside React. Use useTanStackRouterAdapter() hook instead.");
+    }),
+    useLocation: function tanStackUseLocation() {
+      const location = useTanStackLocation();
+      return {
+        pathname: location.pathname,
+        search: location.searchStr || "",
+        hash: location.hash || ""
+      };
+    },
+    useParams: function tanStackUseParams() {
+      return useTanStackParams({ strict: false });
+    },
+    Link: TanStackLinkWrapper
+  };
+}
+function useTanStackNavigateAdapter() {
+  const navigate = useTanStackNavigate();
+  return (options) => {
+    const navOptions = {
+      to: options.to,
+      params: options.params,
+      search: options.search,
+      replace: options.replace
+    };
+    navigate(navOptions);
+  };
+}
+var noopRouterAdapter = {
+  navigate: (_options) => {
+  },
+  useLocation: function noopUseLocation() {
+    return {
+      pathname: "/",
+      search: "",
+      hash: ""
+    };
+  },
+  useParams: function noopUseParams() {
+    return {};
+  },
+  Link: TanStackLinkWrapper
+};
+function useSafeRouter() {
+  try {
+    return useRouter({ warn: false });
+  } catch {
+    return null;
+  }
+}
+function useTanStackRouterAdapter() {
+  const router = useSafeRouter();
+  return useMemo(() => {
+    if (!router) {
+      return noopRouterAdapter;
+    }
+    return {
+      navigate: (options) => {
+        const navOptions = {
+          to: options.to,
+          params: options.params,
+          search: options.search,
+          replace: options.replace
+        };
+        router.navigate(navOptions);
+      },
+      useLocation: function tanStackUseLocation() {
+        const location = useTanStackLocation();
+        return {
+          pathname: location.pathname,
+          search: location.searchStr || "",
+          hash: location.hash || ""
+        };
+      },
+      useParams: function tanStackUseParams() {
+        return useTanStackParams({ strict: false });
+      },
+      Link: TanStackLinkWrapper
+    };
+  }, [router]);
+}
+
+// src/adapters/auth-adapter.ts
+import { useMemo as useMemo2 } from "react";
+function createPolDbHooksAuthValue(auth) {
+  const user = auth.user ? { id: auth.user.id, email: auth.user.email } : auth.user;
+  const profile = auth.profile;
+  const isAuthenticated = Boolean(auth.user) && !auth.isLoading;
+  return {
+    user,
+    profile,
+    isLoading: auth.isLoading,
+    isAuthenticated,
+    access: auth.access ?? [],
+    hasAccess: auth.hasAccess,
+    signInAsync: auth.signInAsync,
+    signOutAsync: auth.signOutAsync,
+    isArchived: auth.isArchived,
+    isSuspended: auth.isSuspended
+  };
+}
+function usePolDbHooksAuthAdapter(useSetupAuthHook) {
+  const auth = useSetupAuthHook();
+  return useMemo2(
+    () => createPolDbHooksAuthValue(auth),
+    [
+      auth.user,
+      auth.profile,
+      auth.isLoading,
+      auth.access,
+      auth.hasAccess,
+      auth.signInAsync,
+      auth.signOutAsync,
+      auth.isArchived,
+      auth.isSuspended
+    ]
+  );
+}
+function createPolDbHooksAuthAdapter(useSetupAuthHook) {
+  return () => usePolDbHooksAuthAdapter(useSetupAuthHook);
+}
+
+// src/adapters/supabase-data-adapter.ts
+import { useMemo as useMemo3 } from "react";
+function applyFilters(query, filters) {
+  if (!filters || filters.length === 0) return query;
+  for (const filter of filters) {
+    const { field, operator, value } = filter;
+    switch (operator) {
+      case "eq":
+        query = query.eq(field, value);
+        break;
+      case "neq":
+        query = query.neq(field, value);
+        break;
+      case "gt":
+        query = query.gt(field, value);
+        break;
+      case "gte":
+        query = query.gte(field, value);
+        break;
+      case "lt":
+        query = query.lt(field, value);
+        break;
+      case "lte":
+        query = query.lte(field, value);
+        break;
+      case "like":
+        query = query.like(field, value);
+        break;
+      case "ilike":
+        query = query.ilike(field, value);
+        break;
+      case "in":
+        query = query.in(field, value);
+        break;
+      case "contains":
+        query = query.contains(field, value);
+        break;
+      case "is":
+        query = query.is(field, value);
+        break;
+      default:
+        console.warn(`Unknown filter operator: ${operator}`);
+    }
+  }
+  return query;
+}
+function applySorting(query, sort) {
+  if (!sort || sort.length === 0) return query;
+  for (const sortItem of sort) {
+    query = query.order(sortItem.field, { ascending: sortItem.direction === "asc" });
+  }
+  return query;
+}
+function applyPagination(query, pagination) {
+  if (!pagination) return query;
+  const { page, pageSize, offset, limit } = pagination;
+  if (offset !== void 0 && limit !== void 0) {
+    return query.range(offset, offset + limit - 1);
+  }
+  if (page !== void 0 && pageSize !== void 0) {
+    const calculatedOffset = (page - 1) * pageSize;
+    return query.range(calculatedOffset, calculatedOffset + pageSize - 1);
+  }
+  if (limit !== void 0) {
+    return query.limit(limit);
+  }
+  return query;
+}
+function createSupabaseDataAdapter(client, options = {}) {
+  const { schema = "public", primaryKey = "id" } = options;
+  const adapter = {
+    async getById(table, id) {
+      const { data, error } = await client.schema(schema).from(table).select("*").eq(primaryKey, id).single();
+      if (error) {
+        if (error.code === "PGRST116") {
+          return null;
+        }
+        throw new Error(`Failed to fetch ${table} by id: ${error.message}`);
+      }
+      return data;
+    },
+    async getMany(table, params) {
+      let query = client.schema(schema).from(table).select(params?.select ?? "*");
+      query = applyFilters(query, params?.filters);
+      query = applySorting(query, params?.sort);
+      query = applyPagination(query, params?.pagination);
+      const { data, error } = await query;
+      if (error) {
+        throw new Error(`Failed to fetch ${table}: ${error.message}`);
+      }
+      return data ?? [];
+    },
+    async getManyWithCount(table, params) {
+      let query = client.schema(schema).from(table).select(params?.select ?? "*", { count: "exact" });
+      query = applyFilters(query, params?.filters);
+      query = applySorting(query, params?.sort);
+      query = applyPagination(query, params?.pagination);
+      const { data, count, error } = await query;
+      if (error) {
+        throw new Error(`Failed to fetch ${table} with count: ${error.message}`);
+      }
+      return {
+        data: data ?? [],
+        count: count ?? 0
+      };
+    },
+    async create(table, data) {
+      const { data: result, error } = await client.schema(schema).from(table).insert(data).select().single();
+      if (error) {
+        throw new Error(`Failed to create ${table}: ${error.message}`);
+      }
+      return result;
+    },
+    async update(table, id, data) {
+      const { data: result, error } = await client.schema(schema).from(table).update(data).eq(primaryKey, id).select().single();
+      if (error) {
+        throw new Error(`Failed to update ${table}: ${error.message}`);
+      }
+      return result;
+    },
+    async delete(table, id) {
+      const { error } = await client.schema(schema).from(table).delete().eq(primaryKey, id);
+      if (error) {
+        throw new Error(`Failed to delete ${table}: ${error.message}`);
+      }
+    },
+    async query(queryFn) {
+      return queryFn();
+    },
+    subscribe(table, callback, filter) {
+      let filterString;
+      if (filter && filter.length > 0) {
+        const eqFilter = filter.find((f) => f.operator === "eq");
+        if (eqFilter) {
+          filterString = `${eqFilter.field}=eq.${eqFilter.value}`;
+        }
+      }
+      const channelName = `${table}-${Date.now()}`;
+      const channel = client.channel(channelName).on(
+        "postgres_changes",
+        {
+          event: "*",
+          schema,
+          table,
+          filter: filterString
+        },
+        (payload) => {
+          const realtimePayload = {
+            eventType: payload.eventType,
+            new: payload.new,
+            old: payload.old,
+            table
+          };
+          callback(realtimePayload);
+        }
+      ).subscribe();
+      return () => {
+        channel.unsubscribe();
+        client.removeChannel(channel);
+      };
+    },
+    async uploadFile(bucket, path, file) {
+      const { data, error } = await client.storage.from(bucket).upload(path, file, {
+        cacheControl: "3600",
+        upsert: false
+      });
+      if (error) {
+        throw new Error(`Failed to upload file: ${error.message}`);
+      }
+      const {
+        data: { publicUrl }
+      } = client.storage.from(bucket).getPublicUrl(data.path);
+      return {
+        path: data.path,
+        url: publicUrl
+      };
+    },
+    getFileUrl(bucket, path) {
+      const {
+        data: { publicUrl }
+      } = client.storage.from(bucket).getPublicUrl(path);
+      return publicUrl;
+    },
+    async deleteFile(bucket, path) {
+      const { error } = await client.storage.from(bucket).remove([path]);
+      if (error) {
+        throw new Error(`Failed to delete file: ${error.message}`);
+      }
+    }
+  };
+  return adapter;
+}
+function useSupabaseDataAdapter(useSupabaseHook, options = {}) {
+  const client = useSupabaseHook();
+  return useMemo3(
+    () => createSupabaseDataAdapter(client, options),
+    [client, options.schema, options.primaryKey]
+  );
+}
+function createSupabaseDataAdapterHook(useSupabaseHook, options = {}) {
+  return () => useSupabaseDataAdapter(useSupabaseHook, options);
+}
+export {
+  createPolDbHooksAuthAdapter,
+  createPolDbHooksAuthValue,
+  createSupabaseDataAdapter,
+  createSupabaseDataAdapterHook,
+  createTanStackRouterAdapter,
+  usePolDbHooksAuthAdapter,
+  useSupabaseDataAdapter,
+  useTanStackNavigateAdapter,
+  useTanStackRouterAdapter
+};