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';
 
 /**
@@ -66,6 +72,22 @@ export type TrimDelegateModelOperations<
     T extends Record<string, unknown>,
 > = IsDelegateModel<Schema, Model> extends true ? Omit<T, HooksOperationsIneligibleForDelegateModels> : T;
 
+type Modifiers = '' | 'Suspense' | 'Infinite' | `SuspenseInfinite`;
+
+/**
+ * Trim hooks based on slicing configuration.
+ */
+export type TrimSlicedHooks<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Options extends QueryOptions<Schema>,
+    T extends Record<string, unknown>,
+> = {
+    [Key in keyof T as Key extends `use${Modifiers}${Capitalize<GetSlicedOperations<Schema, Model, Options>>}`
+        ? 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,
@@ -63,6 +65,7 @@ import type {
     ProcedureReturn,
     QueryContext,
     TrimDelegateModelOperations,
+    TrimSlicedHooks,
     WithOptimistic,
 } from './common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
@@ -148,11 +151,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,136 +198,142 @@ 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> = 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<
+> = TrimSlicedHooks<
     Schema,
     Model,
-    {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
-            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-            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>>,
-            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>>,
-            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>>,
-            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>>,
-            options?: ModelQueryOptions<boolean>,
-        ): ModelQueryResult<boolean>;
-
-        useFindMany<T extends FindManyArgs<Schema, Model>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
-            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>>,
-            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>>,
-            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>>,
-            options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
-        ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
-
-        useCreate<T extends CreateArgs<Schema, Model>>(
-            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>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
-
-        useUpdate<T extends UpdateArgs<Schema, Model>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
-
-        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
-            options?: ModelMutationOptions<BatchResult, T>,
-        ): ModelMutationResult<BatchResult, T>;
-
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
-
-        useUpsert<T extends UpsertArgs<Schema, Model>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
-
-        useDelete<T extends DeleteArgs<Schema, Model>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
-
-        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
-            options?: ModelMutationOptions<BatchResult, T>,
-        ): ModelMutationResult<BatchResult, T>;
-
-        useCount<T extends CountArgs<Schema, Model>>(
-            args?: Subset<T, CountArgs<Schema, Model>>,
-            options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
-        ): ModelQueryResult<CountResult<Schema, Model, T>>;
-
-        useSuspenseCount<T extends CountArgs<Schema, Model>>(
-            args?: Subset<T, CountArgs<Schema, Model>>,
-            options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>,
-        ): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
-
-        useAggregate<T extends AggregateArgs<Schema, Model>>(
-            args: Subset<T, AggregateArgs<Schema, Model>>,
-            options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
-        ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
-
-        useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(
-            args: Subset<T, AggregateArgs<Schema, Model>>,
-            options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>,
-        ): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
-
-        useGroupBy<T extends GroupByArgs<Schema, Model>>(
-            args: Subset<T, GroupByArgs<Schema, Model>>,
-            options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
-        ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
-
-        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
-            args: Subset<T, GroupByArgs<Schema, Model>>,
-            options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>,
-        ): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;
-    }
+    Options,
+    TrimDelegateModelOperations<
+        Schema,
+        Model,
+        {
+            useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+                args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+                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>>,
+                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>>,
+                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>>,
+                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>>,
+                options?: ModelQueryOptions<boolean>,
+            ): ModelQueryResult<boolean>;
+
+            useFindMany<T extends FindManyArgs<Schema, Model>>(
+                args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+                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>>,
+                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>>,
+                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>>,
+                options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
+            ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
+
+            useCreate<T extends CreateArgs<Schema, Model>>(
+                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>>(
+                options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>,
+            ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+
+            useUpdate<T extends UpdateArgs<Schema, Model>>(
+                options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
+            ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+
+            useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+                options?: ModelMutationOptions<BatchResult, T>,
+            ): ModelMutationResult<BatchResult, T>;
+
+            useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
+                options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>,
+            ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+
+            useUpsert<T extends UpsertArgs<Schema, Model>>(
+                options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
+            ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+
+            useDelete<T extends DeleteArgs<Schema, Model>>(
+                options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
+            ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+
+            useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
+                options?: ModelMutationOptions<BatchResult, T>,
+            ): ModelMutationResult<BatchResult, T>;
+
+            useCount<T extends CountArgs<Schema, Model>>(
+                args?: Subset<T, CountArgs<Schema, Model>>,
+                options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
+            ): ModelQueryResult<CountResult<Schema, Model, T>>;
+
+            useSuspenseCount<T extends CountArgs<Schema, Model>>(
+                args?: Subset<T, CountArgs<Schema, Model>>,
+                options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>,
+            ): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
+
+            useAggregate<T extends AggregateArgs<Schema, Model>>(
+                args: Subset<T, AggregateArgs<Schema, Model>>,
+                options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
+            ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
+
+            useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(
+                args: Subset<T, AggregateArgs<Schema, Model>>,
+                options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>,
+            ): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
+
+            useGroupBy<T extends GroupByArgs<Schema, Model>>(
+                args: Subset<T, GroupByArgs<Schema, Model>>,
+                options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
+            ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
+
+            useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
+                args: Subset<T, GroupByArgs<Schema, Model>>,
+                options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>,
+            ): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;
+        }
+    >
 >;
 
 /**