suparisma 1.0.3 → 1.0.4

package/README.md

@@ -303,6 +303,204 @@ const { data } = useSuparisma.thing({
 });
 ```
 
+### Array Filtering
+
+Suparisma provides powerful operators for filtering array fields (e.g., `String[]`, `Int[]`, etc.):
+
+```prisma
+model Post {
+  id       String   @id @default(uuid())
+  title    String
+  tags     String[] // Array field
+  ratings  Int[]    // Array field
+  // ... other fields
+}
+```
+
+#### Array Operators
+
+| Operator | Description | Example Usage |
+|----------|-------------|---------------|
+| `has` | Array contains **ANY** of the specified items | `tags: { has: ["react", "typescript"] }` |
+| `hasSome` | Array contains **ANY** of the specified items (alias for `has`) | `tags: { hasSome: ["react", "vue"] }` |
+| `hasEvery` | Array contains **ALL** of the specified items | `tags: { hasEvery: ["react", "typescript"] }` |
+| `isEmpty` | Array is empty or not empty | `tags: { isEmpty: false }` |
+
+#### Array Filtering Examples
+
+```tsx
+// Find posts that have ANY of these tags
+const { data: reactOrVuePosts } = useSuparisma.post({
+  where: {
+    tags: { has: ["react", "vue", "angular"] }
+  }
+});
+// Returns posts with tags like: ["react"], ["vue"], ["react", "typescript"], etc.
+
+// Find posts that have ALL of these tags
+const { data: fullStackPosts } = useSuparisma.post({
+  where: {
+    tags: { hasEvery: ["react", "typescript", "nodejs"] }
+  }
+});
+// Returns posts that contain all three tags (and possibly more)
+
+// Find posts with any of these ratings
+const { data: highRatedPosts } = useSuparisma.post({
+  where: {
+    ratings: { hasSome: [4, 5] }
+  }
+});
+// Returns posts with arrays containing 4 or 5: [3, 4], [5], [1, 2, 4, 5], etc.
+
+// Find posts with no tags
+const { data: untaggedPosts } = useSuparisma.post({
+  where: {
+    tags: { isEmpty: true }
+  }
+});
+
+// Find posts that have tags (non-empty)
+const { data: taggedPosts } = useSuparisma.post({
+  where: {
+    tags: { isEmpty: false }
+  }
+});
+
+// Combine array filtering with other conditions
+const { data: featuredReactPosts } = useSuparisma.post({
+  where: {
+    tags: { has: ["react"] },
+    featured: true,
+    ratings: { hasEvery: [4, 5] } // Must have both 4 AND 5 ratings
+  }
+});
+
+// Exact array match (regular equality)
+const { data: exactMatch } = useSuparisma.post({
+  where: {
+    tags: ["react", "typescript"] // Exact match: only this array
+  }
+});
+```
+
+#### Real-World Array Filtering Scenarios
+
+```tsx
+// E-commerce: Find products by multiple categories
+const { data: products } = useSuparisma.product({
+  where: {
+    categories: { has: ["electronics", "gaming"] } // Any of these categories
+  }
+});
+
+// Social Media: Find posts with specific hashtags
+const { data: trendingPosts } = useSuparisma.post({
+  where: {
+    hashtags: { hasSome: ["trending", "viral", "popular"] }
+  }
+});
+
+// Project Management: Find tasks assigned to specific team members
+const { data: myTasks } = useSuparisma.task({
+  where: {
+    assignedTo: { has: ["john@company.com"] } // Tasks assigned to John
+  }
+});
+
+// Content Management: Find articles with all required tags
+const { data: completeArticles } = useSuparisma.article({
+  where: {
+    requiredTags: { hasEvery: ["reviewed", "approved", "published"] }
+  }
+});
+```
+
+#### Interactive Array Filtering Component
+
+```tsx
+import { useState } from "react";
+import useSuparisma from '../generated';
+
+function ProductFilter() {
+  const [selectedCategories, setSelectedCategories] = useState<string[]>([]);
+  const [filterMode, setFilterMode] = useState<'any' | 'all'>('any');
+
+  const { data: products, loading } = useSuparisma.product({
+    where: selectedCategories.length > 0 ? {
+      categories: filterMode === 'any' 
+        ? { has: selectedCategories }           // ANY of selected categories
+        : { hasEvery: selectedCategories }      // ALL of selected categories
+    } : undefined
+  });
+
+  const handleCategoryToggle = (category: string) => {
+    setSelectedCategories(prev => 
+      prev.includes(category) 
+        ? prev.filter(c => c !== category)
+        : [...prev, category]
+    );
+  };
+
+  return (
+    <div>
+      {/* Filter Mode Toggle */}
+      <div className="mb-4">
+        <label className="mr-4">
+          <input
+            type="radio"
+            value="any"
+            checked={filterMode === 'any'}
+            onChange={(e) => setFilterMode(e.target.value as 'any')}
+          />
+          Match ANY categories
+        </label>
+        <label>
+          <input
+            type="radio"
+            value="all"
+            checked={filterMode === 'all'}
+            onChange={(e) => setFilterMode(e.target.value as 'all')}
+          />
+          Match ALL categories
+        </label>
+      </div>
+
+      {/* Category Checkboxes */}
+      <div className="mb-4">
+        {['electronics', 'clothing', 'books', 'home', 'sports'].map(category => (
+          <label key={category} className="mr-4">
+            <input
+              type="checkbox"
+              checked={selectedCategories.includes(category)}
+              onChange={() => handleCategoryToggle(category)}
+            />
+            {category}
+          </label>
+        ))}
+      </div>
+
+      {/* Results */}
+      <div>
+        {loading ? (
+          <p>Loading products...</p>
+        ) : (
+          <div>
+            <h3>Found {products?.length || 0} products</h3>
+            {products?.map(product => (
+              <div key={product.id}>
+                <h4>{product.name}</h4>
+                <p>Categories: {product.categories.join(', ')}</p>
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+```
+
 ### Sorting Data
 
 Sort data using Prisma-like ordering:

package/dist/generators/coreGenerator.js

@@ -43,6 +43,18 @@ export type SupabaseQueryBuilder = ReturnType<ReturnType<typeof supabase.from>['
  * @example
  * // Posts with titles containing "news"
  * { title: { contains: "news" } }
+ * 
+ * @example
+ * // Array contains ANY of these items (overlaps)
+ * { tags: { has: ["typescript", "react"] } }
+ * 
+ * @example
+ * // Array contains ALL of these items (contains)
+ * { categories: { hasEvery: ["tech", "programming"] } }
+ * 
+ * @example
+ * // Array contains ANY of these items (same as 'has')
+ * { tags: { hasSome: ["javascript", "python"] } }
  */
 export type FilterOperators<T> = {
   /** Equal to value */
@@ -67,6 +79,16 @@ export type FilterOperators<T> = {
   startsWith?: string;
   /** String ends with value (case insensitive) */
   endsWith?: string;
+  
+  // Array-specific operators
+  /** Array contains ANY of the specified items (for array fields) */
+  has?: T extends Array<infer U> ? U[] : never;
+  /** Array contains ANY of the specified items (alias for 'has') */
+  hasSome?: T extends Array<infer U> ? U[] : never;
+  /** Array contains ALL of the specified items (for array fields) */
+  hasEvery?: T extends Array<infer U> ? U[] : never;
+  /** Array is empty (for array fields) */
+  isEmpty?: T extends Array<any> ? boolean : never;
 };
 
 // Type for a single field in an advanced where filter
@@ -239,6 +261,35 @@ export function buildFilterString<T>(where?: T): string | undefined {
         if ('endsWith' in advancedOps && advancedOps.endsWith !== undefined) {
           filters.push(\`\${key}=ilike.%\${advancedOps.endsWith}\`);
         }
+        
+        // Array-specific operators
+        if ('has' in advancedOps && advancedOps.has !== undefined) {
+          // Array contains ANY of the specified items (overlaps)
+          const arrayValue = JSON.stringify(advancedOps.has);
+          filters.push(\`\${key}=ov.\${arrayValue}\`);
+        }
+        
+        if ('hasEvery' in advancedOps && advancedOps.hasEvery !== undefined) {
+          // Array contains ALL of the specified items (contains)
+          const arrayValue = JSON.stringify(advancedOps.hasEvery);
+          filters.push(\`\${key}=cs.\${arrayValue}\`);
+        }
+        
+        if ('hasSome' in advancedOps && advancedOps.hasSome !== undefined) {
+          // Array contains ANY of the specified items (overlaps)
+          const arrayValue = JSON.stringify(advancedOps.hasSome);
+          filters.push(\`\${key}=ov.\${arrayValue}\`);
+        }
+        
+        if ('isEmpty' in advancedOps && advancedOps.isEmpty !== undefined) {
+          if (advancedOps.isEmpty) {
+            // Check if array is empty
+            filters.push(\`\${key}=eq.{}\`);
+          } else {
+            // Check if array is not empty
+            filters.push(\`\${key}=neq.{}\`);
+          }
+        }
       } else {
         // Simple equality
         filters.push(\`\${key}=eq.\${value}\`);
@@ -316,6 +367,37 @@ export function applyFilter<T>(
           // @ts-ignore: Supabase typing issue
           filteredQuery = filteredQuery.ilike(key, \`%\${advancedOps.endsWith}\`);
         }
+        
+        // Array-specific operators
+        if ('has' in advancedOps && advancedOps.has !== undefined) {
+          // Array contains ANY of the specified items (overlaps)
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.overlaps(key, advancedOps.has);
+        }
+        
+        if ('hasEvery' in advancedOps && advancedOps.hasEvery !== undefined) {
+          // Array contains ALL of the specified items (contains)
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.contains(key, advancedOps.hasEvery);
+        }
+        
+        if ('hasSome' in advancedOps && advancedOps.hasSome !== undefined) {
+          // Array contains ANY of the specified items (overlaps)
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.overlaps(key, advancedOps.hasSome);
+        }
+        
+        if ('isEmpty' in advancedOps && advancedOps.isEmpty !== undefined) {
+          if (advancedOps.isEmpty) {
+            // Check if array is empty
+            // @ts-ignore: Supabase typing issue
+            filteredQuery = filteredQuery.eq(key, []);
+          } else {
+            // Check if array is not empty
+            // @ts-ignore: Supabase typing issue  
+            filteredQuery = filteredQuery.neq(key, []);
+          }
+        }
       } else {
         // Simple equality
         // @ts-ignore: Supabase typing issue

package/dist/generators/typeGenerator.js

@@ -119,7 +119,7 @@ function generateModelTypesFile(model) {
 // Edit the generator script instead
 
 import type { ${modelName} } from '@prisma/client';
-import type { ModelResult, SuparismaOptions, SearchQuery, SearchState } from '../utils/core';
+import type { ModelResult, SuparismaOptions, SearchQuery, SearchState, FilterOperators } from '../utils/core';
 
 /**
  * Extended ${modelName} type that includes relation fields.
@@ -208,8 +208,64 @@ ${withRelationsProps
         .join(',\n')}
  *   }
  * });
+ * 
+ * @example
+ * // Array filtering (for array fields)
+ * ${modelName.toLowerCase()}.findMany({
+ *   where: {
+ *     // Array contains specific items
+${withRelationsProps
+        .filter((p) => p.includes('[]'))
+        .slice(0, 1)
+        .map((p) => {
+        const field = p.trim().split(':')[0].trim();
+        return ` *     ${field}: { has: ["item1", "item2"] }`;
+    })
+        .join(',\n')}
+ *   }
+ * });
  */
-export type ${modelName}WhereInput = Partial<${modelName}WithRelations>;
+export type ${modelName}WhereInput = {
+${model.fields
+        .filter((field) => !relationObjectFields.includes(field.name) && !foreignKeyFields.includes(field.name))
+        .map((field) => {
+        const isOptional = true; // All where fields are optional
+        let baseType;
+        switch (field.type) {
+            case 'Int':
+            case 'Float':
+                baseType = 'number';
+                break;
+            case 'Boolean':
+                baseType = 'boolean';
+                break;
+            case 'DateTime':
+                baseType = 'string'; // ISO date string
+                break;
+            case 'Json':
+                baseType = 'any'; // Or a more specific structured type if available
+                break;
+            default:
+                // Covers String, Enum names (e.g., "SomeEnum"), Bytes, Decimal, etc.
+                baseType = 'string';
+        }
+        const finalType = field.isList ? `${baseType}[]` : baseType;
+        const filterType = `${finalType} | FilterOperators<${finalType}>`;
+        return `  ${field.name}${isOptional ? '?' : ''}: ${filterType};`;
+    })
+        .concat(
+    // Add foreign key fields
+    foreignKeyFields.map((field) => {
+        const fieldInfo = model.fields.find((f) => f.name === field);
+        if (fieldInfo) {
+            const baseType = fieldInfo.type === 'Int' ? 'number' : 'string';
+            const filterType = `${baseType} | FilterOperators<${baseType}>`;
+            return `  ${field}?: ${filterType};`;
+        }
+        return '';
+    }).filter(Boolean))
+        .join('\n')}
+};
 
 /**
  * Unique identifier for finding a specific ${modelName} record.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "suparisma",
-	"version": "1.0.3",
+	"version": "1.0.4",
 	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma.",
 	"main": "dist/index.js",
 	"repository": {