feat: ORM api slicing

packages/auth-adapters/better-auth/src/adapter.ts

@@ -171,7 +171,7 @@ export const zenstackAdapter = <Schema extends SchemaDef>(db: ClientContract<Sch
                     const whereClause = convertWhereClause(model, where);
                     return await modelDb.update({
                         where: whereClause,
-                        data: update as UpdateInput<SchemaDef, GetModels<SchemaDef>>,
+                        data: update as UpdateInput<SchemaDef, GetModels<SchemaDef>, any>,
                     });
                 },
 

packages/clients/tanstack-query/src/common/types.ts

@@ -1,6 +1,12 @@
 import type { Logger, OptimisticDataProvider } from '@zenstackhq/client-helpers';
 import type { FetchFn } from '@zenstackhq/client-helpers/fetch';
-import type { GetProcedureNames, OperationsIneligibleForDelegateModels, ProcedureFunc } from '@zenstackhq/orm';
+import type {
+    GetProcedureNames,
+    GetSlicedOperations,
+    OperationsIneligibleForDelegateModels,
+    ProcedureFunc,
+    QueryOptions,
+} from '@zenstackhq/orm';
 import type { GetModels, IsDelegateModel, SchemaDef } from '@zenstackhq/schema';
 
 /**
@@ -57,14 +63,27 @@ type HooksOperationsIneligibleForDelegateModels = OperationsIneligibleForDelegat
     ? `use${Capitalize<OperationsIneligibleForDelegateModels>}`
     : never;
 
+type Modifiers = '' | 'Suspense' | 'Infinite' | 'SuspenseInfinite';
+
 /**
- * Trim operations that are ineligible for delegate models from the given model operations type.
+ * Trim CRUD operation hooks to include only eligible operations.
  */
-export type TrimDelegateModelOperations<
+export type TrimSlicedOperations<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
+    Options extends QueryOptions<Schema>,
     T extends Record<string, unknown>,
-> = IsDelegateModel<Schema, Model> extends true ? Omit<T, HooksOperationsIneligibleForDelegateModels> : T;
+> = {
+    // trim operations based on slicing options
+    [Key in keyof T as Key extends `use${Modifiers}${Capitalize<GetSlicedOperations<Schema, Model, Options>>}`
+        ? IsDelegateModel<Schema, Model> extends true
+            ? // trim operations ineligible for delegate models
+              Key extends HooksOperationsIneligibleForDelegateModels
+                ? never
+                : Key
+            : Key
+        : never]: T[Key];
+};
 
 type WithOptimisticFlag<T> = T extends object
     ? T & {

packages/clients/tanstack-query/src/react.ts

@@ -39,6 +39,8 @@ import type {
     FindUniqueArgs,
     GetProcedure,
     GetProcedureNames,
+    GetSlicedModels,
+    GetSlicedProcedures,
     GroupByArgs,
     GroupByResult,
     ProcedureEnvelope,
@@ -62,7 +64,7 @@ import type {
     ExtraQueryOptions,
     ProcedureReturn,
     QueryContext,
-    TrimDelegateModelOperations,
+    TrimSlicedOperations,
     WithOptimistic,
 } from './common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
@@ -148,11 +150,11 @@ export type ModelMutationModelResult<
 };
 
 export type ClientHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
-    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
-} & ProcedureHooks<Schema>;
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
+} & ProcedureHooks<Schema, Options>;
 
-type ProcedureHookGroup<Schema extends SchemaDef> = {
-    [Name in GetProcedureNames<Schema>]: GetProcedure<Schema, Name> extends { mutation: true }
+type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
+    [Name in GetSlicedProcedures<Schema, Options>]: GetProcedure<Schema, Name> extends { mutation: true }
         ? {
               useMutation(
                   options?: Omit<
@@ -195,133 +197,135 @@ type ProcedureHookGroup<Schema extends SchemaDef> = {
           };
 };
 
-export type ProcedureHooks<Schema extends SchemaDef> = Schema['procedures'] extends Record<string, any>
-    ? {
-          /**
-           * Custom procedures.
-           */
-          $procs: ProcedureHookGroup<Schema>;
-      }
-    : Record<never, never>;
+export type ProcedureHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema>> =
+    Schema['procedures'] extends Record<string, any>
+        ? {
+              /**
+               * Custom procedures.
+               */
+              $procs: ProcedureHookGroup<Schema, Options>;
+          }
+        : Record<never, never>;
 
 // Note that we can potentially use TypeScript's mapped type to directly map from ORM contract, but that seems
 // to significantly slow down tsc performance ...
 export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-> = TrimDelegateModelOperations<
+> = TrimSlicedOperations<
     Schema,
     Model,
+    Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
-            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>,
         ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
 
-        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model>>(
-            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, Options>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options>>,
             options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>,
         ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model>>(
-            args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>,
         ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
 
-        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model>>(
-            args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
+        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, Options>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options>>,
             options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>,
         ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
 
-        useExists<T extends ExistsArgs<Schema, Model>>(
-            args?: Subset<T, ExistsArgs<Schema, Model>>,
+        useExists<T extends ExistsArgs<Schema, Model, Options>>(
+            args?: Subset<T, ExistsArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<boolean>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+        useFindMany<T extends FindManyArgs<Schema, Model, Options>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
         ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options>[]>;
 
-        useSuspenseFindMany<T extends FindManyArgs<Schema, Model>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, Options>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options>>,
             options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
         ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options>>,
             options?: ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
         ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
 
-        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options>>,
             options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
         ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model>>(
+        useCreate<T extends CreateArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
         ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true, Options>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model>>(
+        useUpdate<T extends UpdateArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
         ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
-        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true, Options>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model>>(
+        useUpsert<T extends UpsertArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
         ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
-        useDelete<T extends DeleteArgs<Schema, Model>>(
+        useDelete<T extends DeleteArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
         ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
-        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCount<T extends CountArgs<Schema, Model>>(
-            args?: Subset<T, CountArgs<Schema, Model>>,
+        useCount<T extends CountArgs<Schema, Model, Options>>(
+            args?: Subset<T, CountArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
         ): ModelQueryResult<CountResult<Schema, Model, T>>;
 
-        useSuspenseCount<T extends CountArgs<Schema, Model>>(
-            args?: Subset<T, CountArgs<Schema, Model>>,
+        useSuspenseCount<T extends CountArgs<Schema, Model, Options>>(
+            args?: Subset<T, CountArgs<Schema, Model, Options>>,
             options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>,
         ): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
 
-        useAggregate<T extends AggregateArgs<Schema, Model>>(
-            args: Subset<T, AggregateArgs<Schema, Model>>,
+        useAggregate<T extends AggregateArgs<Schema, Model, Options>>(
+            args: Subset<T, AggregateArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
         ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
 
-        useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(
-            args: Subset<T, AggregateArgs<Schema, Model>>,
+        useSuspenseAggregate<T extends AggregateArgs<Schema, Model, Options>>(
+            args: Subset<T, AggregateArgs<Schema, Model, Options>>,
             options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>,
         ): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
 
-        useGroupBy<T extends GroupByArgs<Schema, Model>>(
-            args: Subset<T, GroupByArgs<Schema, Model>>,
+        useGroupBy<T extends GroupByArgs<Schema, Model, Options>>(
+            args: Subset<T, GroupByArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
         ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
 
-        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
-            args: Subset<T, GroupByArgs<Schema, Model>>,
+        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model, Options>>(
+            args: Subset<T, GroupByArgs<Schema, Model, Options>>,
             options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>,
         ): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;
     }