suparisma 1.2.1 → 1.2.3

package/README.md

@@ -16,6 +16,7 @@ A powerful, typesafe React hook generator for Supabase, driven by your Prisma sc
 - [Why Suparisma?](#why-suparisma)
 - [Features](#features)
 - [Installation](#installation)
+- [React Native / Expo Setup](#react-native--expo-setup)
 - [Quick Start](#quick-start)
 - [Detailed Usage](#detailed-usage)
   - [Basic CRUD Operations](#basic-crud-operations)
@@ -25,6 +26,8 @@ A powerful, typesafe React hook generator for Supabase, driven by your Prisma sc
   - [Array Filtering](#array-filtering)
   - [Sorting Data](#sorting-data)
   - [Pagination](#pagination)
+  - [Field Selection (select)](#field-selection-select)
+  - [Including Relations (include)](#including-relations-include)
   - [Search Functionality](#search-functionality)
     - [Enabling Search](#enabling-search)
     - [Search Methods](#search-methods)
@@ -60,7 +63,7 @@ Suparisma bridges this gap by:
 - Enabling easy **pagination, filtering, and search** on your data
 - Leveraging both **Prisma** and **Supabase** official SDKs
 - Respecting **Supabase's auth rules** for secure database access
-- Working seamlessly with any React environment (Next.js, Remix, Tanstack Router, etc.)
+- Working seamlessly with any React environment (Next.js, Remix, Tanstack Router, React Native, etc.)
 
 ## Features
 
@@ -70,7 +73,7 @@ Suparisma bridges this gap by:
 - 🔍 **Full-text search** with configurable annotations *(currently under maintenance)*
 - 🔢 **Pagination and sorting** built into every hook
 - 🧩 **Prisma-like API** that feels familiar if you already use Prisma
-- 📱 **Works with any React framework** including Next.js, Remix, etc.
+- 📱 **Works with any React framework** including Next.js, Remix, React Native, and Expo
 - 🛠️ **Simple CLI** to generate hooks with a single command
 
 ## Installation
@@ -86,6 +89,110 @@ yarn add suparisma
 pnpm install suparisma
 ```
 
+## React Native / Expo Setup
+
+Suparisma fully supports React Native and Expo projects. Follow these additional steps for mobile development:
+
+### 1. Install Dependencies
+
+```bash
+# Install Suparisma and required dependencies
+pnpm install suparisma @supabase/supabase-js @react-native-async-storage/async-storage react-native-url-polyfill
+
+# For UUID generation support (recommended)
+pnpm install react-native-get-random-values
+```
+
+### 2. Add Polyfills
+
+Add these imports at the very top of your app's entry point (e.g., `App.tsx` or `index.js`):
+
+```tsx
+// App.tsx or index.js - Add these at the VERY TOP before any other imports
+import 'react-native-get-random-values'; // Required for UUID generation
+import 'react-native-url-polyfill/auto'; // Required for Supabase
+```
+
+### 3. Set Environment Variables
+
+For **Expo** projects, use the `EXPO_PUBLIC_` prefix in your `.env` file:
+
+```bash
+EXPO_PUBLIC_SUPABASE_URL="https://your-project.supabase.co"
+EXPO_PUBLIC_SUPABASE_ANON_KEY="your-anon-key"
+```
+
+For **bare React Native** projects, use `react-native-dotenv` or similar.
+
+### 4. Generate Hooks for React Native
+
+Set the `SUPARISMA_PLATFORM` environment variable when generating:
+
+```bash
+# Generate hooks for React Native / Expo
+SUPARISMA_PLATFORM=react-native npx suparisma generate
+```
+
+Or add it to your `package.json` scripts:
+
+```json
+{
+  "scripts": {
+    "suparisma:generate": "SUPARISMA_PLATFORM=react-native npx suparisma generate"
+  }
+}
+```
+
+### 5. Use the Hooks
+
+The hooks work exactly the same as in web projects:
+
+```tsx
+import React from 'react';
+import { View, Text, FlatList, TouchableOpacity } from 'react-native';
+import useSuparisma from './src/suparisma/generated';
+
+function ThingList() {
+  const { 
+    data: things,
+    loading,
+    error,
+    create: createThing
+  } = useSuparisma.thing();
+  
+  if (loading) return <Text>Loading...</Text>;
+  if (error) return <Text>Error: {error.message}</Text>;
+  
+  return (
+    <View>
+      <FlatList
+        data={things}
+        keyExtractor={(item) => item.id}
+        renderItem={({ item }) => (
+          <Text>{item.name} (Number: {item.someNumber})</Text>
+        )}
+      />
+      
+      <TouchableOpacity 
+        onPress={() => createThing({ 
+          name: "New Thing", 
+          someNumber: Math.floor(Math.random() * 100)
+        })}
+      >
+        <Text>Add Thing</Text>
+      </TouchableOpacity>
+    </View>
+  );
+}
+```
+
+### Platform Detection
+
+The generated Supabase client automatically configures itself for React Native with:
+- **AsyncStorage** for auth persistence
+- **Session detection** disabled (not applicable in mobile)
+- **Auto refresh token** enabled
+
 ## Quick Start
 
 1. **Add a Prisma schema**: Ensure you have a valid `prisma/schema.prisma` file in your project
@@ -139,6 +246,7 @@ Note: you can adjust the prisma schema path and the generated files output path
 ```bash
 SUPARISMA_PRISMA_SCHEMA_PATH="./prisma/schema.prisma"
 SUPARISMA_OUTPUT_DIR="./src/suparisma/generated"
+SUPARISMA_PLATFORM="web" # or "react-native" for React Native/Expo projects
 ```
 Also make sure to not change any of these generated files directly as **they will always be overwritten**
 
@@ -627,6 +735,53 @@ const { data: page2 } = useSuparisma.thing({
 const { data, count } = useSuparisma.thing();
 ```
 
+### Field Selection (select)
+
+Use the `select` option to only return specific fields, reducing payload size:
+
+```tsx
+// Only get id and name fields
+const { data: things } = useSuparisma.thing({
+  select: { id: true, name: true }
+});
+// Returns: [{ id: "123", name: "Thing 1" }, ...]
+
+// Combine with filtering
+const { data: activeThings } = useSuparisma.thing({
+  where: { someEnum: "ONE" },
+  select: { id: true, name: true, someNumber: true }
+});
+```
+
+### Including Relations (include)
+
+Use the `include` option to fetch related records (foreign key relations):
+
+```tsx
+// Include all fields from a related model
+const { data: posts } = useSuparisma.post({
+  include: { author: true }
+});
+// Returns: [{ id: "123", title: "...", author: { id: "456", name: "John" } }, ...]
+
+// Include specific fields from a relation
+const { data: posts } = useSuparisma.post({
+  include: { 
+    author: { 
+      select: { id: true, name: true } 
+    } 
+  }
+});
+
+// Combine select and include
+const { data: posts } = useSuparisma.post({
+  select: { id: true, title: true },
+  include: { author: true, comments: true }
+});
+```
+
+**Note:** The relation names in `include` should match your Prisma schema relation field names.
+
 ### Search Functionality
 
 Suparisma provides powerful PostgreSQL full-text search capabilities with automatic RPC function generation and type-safe search methods. Search is enabled per field using annotations in your Prisma schema.
@@ -1291,10 +1446,13 @@ export default function ThingTable() {
 |----------|----------|-------------|---------|
 | `DATABASE_URL` | Yes | Postgres database URL used by Prisma | `postgresql://user:pass@host:port/db` |
 | `DIRECT_URL` | Yes | Direct URL to Postgres DB for realtime setup | `postgresql://user:pass@host:port/db` |
-| `NEXT_PUBLIC_SUPABASE_URL` | Yes | Your Supabase project URL | `https://xyz.supabase.co` |
-| `NEXT_PUBLIC_SUPABASE_ANON_KEY` | Yes | Supabase anonymous key | `eyJh...` |
+| `NEXT_PUBLIC_SUPABASE_URL` | Yes (Web) | Your Supabase project URL (Next.js) | `https://xyz.supabase.co` |
+| `NEXT_PUBLIC_SUPABASE_ANON_KEY` | Yes (Web) | Supabase anonymous key (Next.js) | `eyJh...` |
+| `EXPO_PUBLIC_SUPABASE_URL` | Yes (RN) | Your Supabase project URL (Expo) | `https://xyz.supabase.co` |
+| `EXPO_PUBLIC_SUPABASE_ANON_KEY` | Yes (RN) | Supabase anonymous key (Expo) | `eyJh...` |
 | `SUPARISMA_OUTPUT_DIR` | No | Custom output directory | `src/lib/suparisma` |
 | `SUPARISMA_PRISMA_SCHEMA_PATH` | No | Custom schema path | `db/schema.prisma` |
+| `SUPARISMA_PLATFORM` | No | Target platform: `web` or `react-native` | `react-native` |
 
 ### CLI Commands
 
@@ -1416,8 +1574,8 @@ const { data } = useSuparisma.thing({
 | `limit` | `number` | Maximum number of records to return |
 | `offset` | `number` | Number of records to skip for pagination |
 | `realtime` | `boolean` | Enable/disable real-time updates |
-| `select` | `object` | Fields to include in the response |
-| `include` | `object` | Related records to include |
+| `select` | `object` | Fields to include in the response. Use `{ fieldName: true }` syntax |
+| `include` | `object` | Related records to include. Use `{ relationName: true }` or `{ relationName: { select: {...} } }` |
 | `search` | `object` | Full-text search configuration |
 
 ### Hook Return Value
@@ -1464,6 +1622,12 @@ GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO anon;
 ALTER DEFAULT PRIVILEGES IN SCHEMA public
 GRANT USAGE, SELECT ON SEQUENCES TO anon;
 ```
+ 
+You could also try debugging on a table, the following is NOT recommended but you can debug permissions given to anon, service_account and give all access to anon key to make sure that's not the issue:
+```sql
+GRANT ALL ON TABLE "(tableName)" TO anon;
+GRANT ALL ON TABLE "(tableName)" TO authenticated;
+```
 
 **"Unknown command: undefined"**
 

package/dist/config.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HOOK_NAME_PREFIX = exports.UTILS_DIR = exports.HOOKS_DIR = exports.TYPES_DIR = exports.OUTPUT_DIR = exports.PRISMA_SCHEMA_PATH = void 0;
+exports.PLATFORM = exports.HOOK_NAME_PREFIX = exports.UTILS_DIR = exports.HOOKS_DIR = exports.TYPES_DIR = exports.OUTPUT_DIR = exports.PRISMA_SCHEMA_PATH = void 0;
 // Configuration
 const path_1 = __importDefault(require("path"));
 // Use current working directory for all paths
@@ -14,3 +14,4 @@ exports.TYPES_DIR = `${exports.OUTPUT_DIR}/types`;
 exports.HOOKS_DIR = `${exports.OUTPUT_DIR}/hooks`;
 exports.UTILS_DIR = `${exports.OUTPUT_DIR}/utils`;
 exports.HOOK_NAME_PREFIX = 'useSuparisma';
+exports.PLATFORM = process.env.SUPARISMA_PLATFORM || 'web';

package/dist/generators/coreGenerator.js

@@ -47,6 +47,42 @@ export function escapeRegexCharacters(str: string): string {
   return str.replace(/[()\\[\\]{}+*?^$|.\\\\]/g, '\\\\\\\\$&');
 }
 
+/**
+ * Generate a UUID v4, with fallback for environments without crypto.randomUUID()
+ * Works in: browsers, Node.js, and React Native (with react-native-get-random-values polyfill)
+ * 
+ * For React Native, ensure you have installed and imported the polyfill:
+ * - pnpm install react-native-get-random-values
+ * - Import at app entry point: import 'react-native-get-random-values';
+ */
+export function generateUUID(): string {
+  // Try native crypto.randomUUID() first (modern browsers & Node.js 16.7+)
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  
+  // Fallback using crypto.getRandomValues() (works with react-native-get-random-values polyfill)
+  if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    
+    // Set version (4) and variant (RFC 4122)
+    bytes[6] = (bytes[6] & 0x0f) | 0x40; // Version 4
+    bytes[8] = (bytes[8] & 0x3f) | 0x80; // Variant RFC 4122
+    
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+    return \`\${hex.slice(0, 8)}-\${hex.slice(8, 12)}-\${hex.slice(12, 16)}-\${hex.slice(16, 20)}-\${hex.slice(20)}\`;
+  }
+  
+  // Last resort fallback using Math.random() (not cryptographically secure)
+  console.warn('[Suparisma] crypto API not available, using Math.random() fallback for UUID generation');
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
 /**
  * Advanced filter operators for complex queries
  * @example
@@ -133,7 +169,36 @@ export type AdvancedWhereInput<T> = {
  *   limit: 10
  * });
  */
-export type SuparismaOptions<TWhereInput, TOrderByInput> = {
+/**
+ * Select input type - specify which fields to return
+ * Use true to include a field, or use an object for relations
+ * @example
+ * // Select specific fields
+ * { id: true, name: true, email: true }
+ * 
+ * @example
+ * // Select fields with relations
+ * { id: true, name: true, posts: true }
+ */
+export type SelectInput<T> = {
+  [K in keyof T]?: boolean;
+};
+
+/**
+ * Include input type - specify which relations to include
+ * @example
+ * // Include a relation with all fields
+ * { posts: true }
+ * 
+ * @example
+ * // Include a relation with specific fields
+ * { posts: { select: { id: true, title: true } } }
+ */
+export type IncludeInput = {
+  [key: string]: boolean | { select?: Record<string, boolean> };
+};
+
+export type SuparismaOptions<TWhereInput, TOrderByInput, TSelectInput = Record<string, boolean>> = {
   /** Whether to enable realtime updates (default: true) */
   realtime?: boolean;
   /** Custom channel name for realtime subscription */
@@ -148,6 +213,16 @@ export type SuparismaOptions<TWhereInput, TOrderByInput> = {
   limit?: number;
   /** Offset for pagination (skip records) */
   offset?: number;
+  /** 
+   * Select specific fields to return. Reduces payload size.
+   * @example { id: true, name: true, email: true }
+   */
+  select?: TSelectInput;
+  /**
+   * Include related records (foreign key relations).
+   * @example { posts: true } or { posts: { select: { id: true, title: true } } }
+   */
+  include?: IncludeInput;
 };
 
 /**
@@ -697,6 +772,82 @@ function matchesFilter<T>(record: any, filter: T): boolean {
   return conditions.every(condition => condition);
 }
 
+/**
+ * Build a Supabase select string from select and include options.
+ * 
+ * @param select - Object specifying which fields to select { field: true }
+ * @param include - Object specifying which relations to include { relation: true }
+ * @returns A Supabase-compatible select string
+ * 
+ * @example
+ * // Select specific fields
+ * buildSelectString({ id: true, name: true }) // Returns "id,name"
+ * 
+ * @example
+ * // Include relations
+ * buildSelectString(undefined, { posts: true }) // Returns "*,posts(*)"
+ * 
+ * @example
+ * // Select fields and include relations with specific fields
+ * buildSelectString({ id: true, name: true }, { posts: { select: { id: true, title: true } } })
+ * // Returns "id,name,posts(id,title)"
+ */
+export function buildSelectString<TSelect, TInclude>(
+  select?: TSelect,
+  include?: TInclude
+): string {
+  const parts: string[] = [];
+  
+  // Handle select - if provided, only return specified fields
+  if (select && typeof select === 'object') {
+    const selectedFields = Object.entries(select)
+      .filter(([_, value]) => value === true)
+      .map(([key]) => key);
+    
+    if (selectedFields.length > 0) {
+      parts.push(...selectedFields);
+    }
+  }
+  
+  // Handle include - add related records
+  if (include && typeof include === 'object') {
+    for (const [relationName, relationValue] of Object.entries(include)) {
+      if (relationValue === true) {
+        // Include all fields from the relation
+        parts.push(\`\${relationName}(*)\`);
+      } else if (typeof relationValue === 'object' && relationValue !== null) {
+        // Include specific fields from the relation
+        const relationOptions = relationValue as { select?: Record<string, boolean> };
+        if (relationOptions.select) {
+          const relationFields = Object.entries(relationOptions.select)
+            .filter(([_, value]) => value === true)
+            .map(([key]) => key);
+          
+          if (relationFields.length > 0) {
+            parts.push(\`\${relationName}(\${relationFields.join(',')})\`);
+          } else {
+            parts.push(\`\${relationName}(*)\`);
+          }
+        } else {
+          parts.push(\`\${relationName}(*)\`);
+        }
+      }
+    }
+  }
+  
+  // If no select specified but include is, we need to include base table fields too
+  if (parts.length === 0) {
+    return '*';
+  }
+  
+  // If only include was specified (no select), we need all base fields plus relations
+  if (!select && include) {
+    return '*,' + parts.join(',');
+  }
+  
+  return parts.join(',');
+}
+
 /**
  * Apply order by to the query builder
  */
@@ -792,13 +943,19 @@ export function createSuparismaHook<
       orderBy,
       limit,
       offset,
+      select,
+      include,
     } = options;
     
+    // Build the select string once for reuse
+    const selectString = buildSelectString(select, include);
+    
     // Refs to store the latest options for realtime handlers
     const whereRef = useRef(where);
     const orderByRef = useRef(orderBy);
     const limitRef = useRef(limit);
     const offsetRef = useRef(offset);
+    const selectStringRef = useRef(selectString);
 
     // Update refs whenever options change
     useEffect(() => {
@@ -817,6 +974,10 @@ export function createSuparismaHook<
       offsetRef.current = offset;
     }, [offset]);
 
+    useEffect(() => {
+      selectStringRef.current = selectString;
+    }, [selectString]);
+
     // Single data collection for holding results
     const [data, setData] = useState<TWithRelations[]>([]);
     const [error, setError] = useState<Error | null>(null);
@@ -1162,7 +1323,8 @@ export function createSuparismaHook<
         setLoading(true);
         setError(null);
         
-        let query = supabase.from(tableName).select('*');
+        // Use selectString for field selection (includes relations if specified)
+        let query = supabase.from(tableName).select(selectString);
         
         // Apply where conditions if provided
         if (params?.where) {
@@ -1249,7 +1411,7 @@ export function createSuparismaHook<
         
         const { data, error } = await supabase
           .from(tableName)
-          .select('*')
+          .select(selectString)
           .eq(primaryKey, value)
           .maybeSingle();
         
@@ -1572,7 +1734,7 @@ export function createSuparismaHook<
     }, [realtime, channelName, tableName]); // NEVER include 'where' - subscription should persist
 
     // Create a memoized options object to prevent unnecessary re-renders
-    const optionsRef = useRef({ where, orderBy, limit, offset });
+    const optionsRef = useRef({ where, orderBy, limit, offset, selectString });
     
     // Compare current options with previous options
     const optionsChanged = useCallback(() => {
@@ -1587,16 +1749,17 @@ export function createSuparismaHook<
         whereStr !== prevWhereStr ||
         orderByStr !== prevOrderByStr ||
         limit !== optionsRef.current.limit ||
-        offset !== optionsRef.current.offset;
+        offset !== optionsRef.current.offset ||
+        selectString !== optionsRef.current.selectString;
       
       if (hasChanged) {
         // Update the ref with the new values
-        optionsRef.current = { where, orderBy, limit, offset };
+        optionsRef.current = { where, orderBy, limit, offset, selectString };
         return true;
       }
       
       return false;
-    }, [where, orderBy, limit, offset]);
+    }, [where, orderBy, limit, offset, selectString]);
 
     // Load initial data and refetch when options change (BUT NEVER TOUCH SUBSCRIPTION)
     useEffect(() => {
@@ -1690,7 +1853,7 @@ export function createSuparismaHook<
             if (defaultValue.includes('now()') || defaultValue.includes('now')) {
               appliedDefaults[field] = now.toISOString(); // Database expects ISO string
             } else if (defaultValue.includes('uuid()') || defaultValue.includes('uuid')) {
-              appliedDefaults[field] = crypto.randomUUID();
+              appliedDefaults[field] = generateUUID();
             } else if (defaultValue.includes('cuid()') || defaultValue.includes('cuid')) {
               // Simple cuid-like implementation for client-side
               appliedDefaults[field] = 'c' + Math.random().toString(36).substring(2, 15);
@@ -1720,7 +1883,7 @@ export function createSuparismaHook<
         const { data: result, error } = await supabase
           .from(tableName)
           .insert([itemWithDefaults])
-          .select();
+          .select(selectString);
         
         if (error) throw error;
         
@@ -1812,7 +1975,7 @@ export function createSuparismaHook<
           .from(tableName)
           .update(itemWithDefaults)
           .eq(primaryKey, value)
-          .select();
+          .select(selectString);
         
         if (error) throw error;
         
@@ -1867,7 +2030,7 @@ export function createSuparismaHook<
         // First fetch the record to return it
         const { data: recordToDelete } = await supabase
           .from(tableName)
-          .select('*')
+          .select(selectString)
           .eq(primaryKey, value)
           .maybeSingle();
         

package/dist/generators/hookGenerator.js

@@ -42,6 +42,8 @@ import type {
   ${modelName}WhereInput,
   ${modelName}WhereUniqueInput,
   ${modelName}OrderByInput,
+  ${modelName}SelectInput,
+  ${modelName}IncludeInput,
   ${modelName}HookApi,
   Use${modelName}Options
 } from '../types/${modelName}Types';
@@ -92,6 +94,18 @@ import type {
  *   orderBy: { // ordering },
  *   take: 20 // limit
  * });
+ * 
+ * @example
+ * // Select specific fields only
+ * const ${modelName.toLowerCase()} = ${config_1.HOOK_NAME_PREFIX}${modelName}({
+ *   select: { id: true, name: true }
+ * });
+ * 
+ * @example
+ * // Include related records
+ * const ${modelName.toLowerCase()} = ${config_1.HOOK_NAME_PREFIX}${modelName}({
+ *   include: { relatedModel: true }
+ * });
  */
 export const ${config_1.HOOK_NAME_PREFIX}${modelName} = createSuparismaHook<
   ${modelName}WithRelations,

package/dist/generators/supabaseClientGenerator.js

@@ -6,21 +6,83 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSupabaseClientFile = generateSupabaseClientFile;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const config_1 = require("../config"); // Ensure this is UTILS_DIR
+const config_1 = require("../config");
+/**
+ * Generate the Supabase client file based on the target platform.
+ * Supports both web (Next.js, etc.) and React Native/Expo.
+ */
 function generateSupabaseClientFile() {
-    const supabaseClientContent = `// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+    let supabaseClientContent;
+    if (config_1.PLATFORM === 'react-native') {
+        // React Native / Expo compatible client
+        supabaseClientContent = `// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+// Platform: React Native / Expo
+//
+// IMPORTANT: Before using Suparisma in React Native, ensure you have:
+// 1. Installed required dependencies:
+//    pnpm install @supabase/supabase-js @react-native-async-storage/async-storage react-native-url-polyfill
+//
+// 2. Added polyfills at your app's entry point (e.g., App.tsx or index.js):
+//    import 'react-native-url-polyfill/auto';
+//
+// 3. Set your Supabase credentials below or via environment variables
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
 import { createClient } from '@supabase/supabase-js';
 
-export const supabase = createClient(
-  process.env.NEXT_PUBLIC_SUPABASE_URL!,
-  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
-);
+// Option 1: Set your Supabase credentials directly (for quick setup)
+// const SUPABASE_URL = 'https://your-project.supabase.co';
+// const SUPABASE_ANON_KEY = 'your-anon-key';
+
+// Option 2: Use environment variables (recommended for production)
+// With Expo, use expo-constants or babel-plugin-inline-dotenv
+// With bare React Native, use react-native-dotenv
+const SUPABASE_URL = process.env.EXPO_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || '';
+const SUPABASE_ANON_KEY = process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY || process.env.SUPABASE_ANON_KEY || '';
+
+if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+  console.warn(
+    '[Suparisma] Supabase credentials not found. Please set EXPO_PUBLIC_SUPABASE_URL and EXPO_PUBLIC_SUPABASE_ANON_KEY ' +
+    'in your environment variables, or update the credentials directly in this file.'
+  );
+}
+
+export const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+  auth: {
+    storage: AsyncStorage,
+    autoRefreshToken: true,
+    persistSession: true,
+    detectSessionInUrl: false, // Important for React Native
+  },
+});
 `;
+    }
+    else {
+        // Web platform (Next.js, Remix, etc.)
+        supabaseClientContent = `// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+// Platform: Web (Next.js, Remix, etc.)
+import { createClient } from '@supabase/supabase-js';
+
+// For Next.js, use NEXT_PUBLIC_ prefix
+// For other frameworks, adjust the environment variable names as needed
+const SUPABASE_URL = process.env.NEXT_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || '';
+const SUPABASE_ANON_KEY = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || process.env.SUPABASE_ANON_KEY || '';
+
+if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+  console.warn(
+    '[Suparisma] Supabase credentials not found. Please set NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY ' +
+    '(or SUPABASE_URL and SUPABASE_ANON_KEY) in your environment variables.'
+  );
+}
+
+export const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+`;
+    }
     // Output to the UTILS_DIR
     const outputPath = path_1.default.join(config_1.UTILS_DIR, 'supabase-client.ts');
     if (!fs_1.default.existsSync(config_1.UTILS_DIR)) {
         fs_1.default.mkdirSync(config_1.UTILS_DIR, { recursive: true });
     }
     fs_1.default.writeFileSync(outputPath, supabaseClientContent);
-    console.log(`🚀 Generated Supabase client file at: ${outputPath}`);
+    console.log(`🚀 Generated Supabase client file at: ${outputPath} (platform: ${config_1.PLATFORM})`);
 }

package/dist/generators/typeGenerator.js

@@ -352,6 +352,40 @@ export type ${modelName}OrderByInput = {
   [key in keyof ${modelName}WithRelations]?: 'asc' | 'desc';
 };
 
+/**
+ * Select specific fields to return from ${modelName} queries.
+ * Set fields to \`true\` to include them in the response.
+ * 
+ * @example
+ * // Only return id and name
+ * ${modelName.toLowerCase()}.findMany({
+ *   select: { id: true, name: true }
+ * });
+ */
+export type ${modelName}SelectInput = {
+  [key in keyof ${modelName}WithRelations]?: boolean;
+};
+
+/**
+ * Include related records when querying ${modelName}.
+ * Set relation names to \`true\` to include all fields, or use an object to select specific fields.
+ * 
+ * @example
+ * // Include all fields from a relation
+ * ${modelName.toLowerCase()}.findMany({
+ *   include: { relatedModel: true }
+ * });
+ * 
+ * @example
+ * // Include specific fields from a relation
+ * ${modelName.toLowerCase()}.findMany({
+ *   include: { relatedModel: { select: { id: true, name: true } } }
+ * });
+ */
+export type ${modelName}IncludeInput = {
+  [key: string]: boolean | { select?: Record<string, boolean> };
+};
+
 /**
  * Result type for operations that return a single ${modelName} record.
  */
@@ -364,8 +398,12 @@ export type ${modelName}ManyResult = ModelResult<${modelName}WithRelations[]>;
 
 /**
  * Configuration options for the ${modelName} hook.
+ * Includes where filters, ordering, pagination, and field selection.
  */
-export type Use${modelName}Options = SuparismaOptions<${modelName}WhereInput, ${modelName}OrderByInput>;
+export type Use${modelName}Options = SuparismaOptions<${modelName}WhereInput, ${modelName}OrderByInput, ${modelName}SelectInput> & {
+  /** Include related records (foreign key relations) */
+  include?: ${modelName}IncludeInput;
+};
 
 /**
  * The complete API for interacting with ${modelName} records.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "suparisma",
-	"version": "1.2.1",
-	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma.",
+	"version": "1.2.3",
+	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma. Works with Next.js, Remix, React Native, and Expo.",
 	"main": "dist/index.js",
 	"repository": {
 		"type": "git",
@@ -20,12 +20,15 @@
 	},
 	"keywords": [
 		"react",
+		"react-native",
+		"expo",
 		"hooks",
 		"supabase",
 		"prisma",
 		"typescript",
 		"nextjs",
-		"realtime"
+		"realtime",
+		"mobile"
 	],
 	"dependencies": {
 		"@supabase/supabase-js": "^2.49.4",
@@ -41,5 +44,21 @@
 		"@types/react": "^19.1.4",
 		"prisma": "^6.8.2",
 		"supabase-js": "link:@types/@supabase/supabase-js"
+	},
+	"peerDependencies": {
+		"@react-native-async-storage/async-storage": ">=1.19.0",
+		"react-native-get-random-values": ">=1.9.0",
+		"react-native-url-polyfill": ">=2.0.0"
+	},
+	"peerDependenciesMeta": {
+		"@react-native-async-storage/async-storage": {
+			"optional": true
+		},
+		"react-native-get-random-values": {
+			"optional": true
+		},
+		"react-native-url-polyfill": {
+			"optional": true
+		}
 	}
 }