@zenstackhq/tanstack-query 3.0.0-beta.17 → 3.0.0-beta.18

package/src/vue.ts

@@ -0,0 +1,429 @@
+import {
+    useInfiniteQuery,
+    useMutation,
+    useQuery,
+    useQueryClient,
+    type DefaultError,
+    type InfiniteData,
+    type QueryKey,
+    type UseInfiniteQueryOptions,
+    type UseInfiniteQueryReturnType,
+    type UseMutationOptions,
+    type UseMutationReturnType,
+    type UseQueryOptions,
+    type UseQueryReturnType,
+} from '@tanstack/vue-query';
+import { lowerCaseFirst } from '@zenstackhq/common-helpers';
+import type {
+    AggregateArgs,
+    AggregateResult,
+    BatchResult,
+    CountArgs,
+    CountResult,
+    CreateArgs,
+    CreateManyAndReturnArgs,
+    CreateManyArgs,
+    DeleteArgs,
+    DeleteManyArgs,
+    FindArgs,
+    FindUniqueArgs,
+    GroupByArgs,
+    GroupByResult,
+    ModelResult,
+    SelectIncludeOmit,
+    SelectSubset,
+    Subset,
+    UpdateArgs,
+    UpdateManyAndReturnArgs,
+    UpdateManyArgs,
+    UpsertArgs,
+} from '@zenstackhq/orm';
+import type { GetModels, SchemaDef } from '@zenstackhq/schema';
+import { inject, provide, toValue, type MaybeRefOrGetter, type UnwrapRef } from 'vue';
+import {
+    DEFAULT_QUERY_ENDPOINT,
+    fetcher,
+    getQueryKey,
+    makeUrl,
+    marshal,
+    setupInvalidation,
+    setupOptimisticUpdate,
+    type APIContext,
+    type ExtraMutationOptions,
+    type ExtraQueryOptions,
+} from './utils/common';
+import type { TrimDelegateModelOperations } from './utils/types';
+
+export type { FetchFn } from './utils/common';
+export const VueQueryContextKey = 'zenstack-vue-query-context';
+
+/**
+ * Provide context for query settings.
+ *
+ * @deprecated Use {@link provideQuerySettingsContext} instead.
+ */
+export function provideHooksContext(context: APIContext) {
+    provide<APIContext>(VueQueryContextKey, context);
+}
+
+/**
+ * Provide context for query settings.
+ */
+export function provideQuerySettingsContext(context: APIContext) {
+    provide<APIContext>(VueQueryContextKey, context);
+}
+
+function getQuerySettings() {
+    const { endpoint, ...rest } = inject<APIContext>(VueQueryContextKey, {
+        endpoint: DEFAULT_QUERY_ENDPOINT,
+        fetch: undefined,
+        logging: false,
+    });
+    return { endpoint: endpoint ?? DEFAULT_QUERY_ENDPOINT, ...rest };
+}
+
+export type ModelQueryOptions<T> = MaybeRefOrGetter<
+    Omit<UnwrapRef<UseQueryOptions<T, DefaultError>>, 'queryKey'> & ExtraQueryOptions
+>;
+
+export type ModelQueryResult<T> = UseQueryReturnType<T, DefaultError> & { queryKey: QueryKey };
+
+export type ModelInfiniteQueryOptions<T> = MaybeRefOrGetter<
+    Omit<UnwrapRef<UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T>>>, 'queryKey' | 'initialPageParam'>
+>;
+
+export type ModelInfiniteQueryResult<T> = UseInfiniteQueryReturnType<T, DefaultError> & { queryKey: QueryKey };
+
+export type ModelMutationOptions<T, TArgs> = MaybeRefOrGetter<
+    Omit<UnwrapRef<UseMutationOptions<T, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions
+>;
+
+export type ModelMutationResult<T, TArgs> = UseMutationReturnType<T, DefaultError, TArgs, unknown>;
+
+export type ModelMutationModelResult<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    TArgs extends SelectIncludeOmit<Schema, Model, boolean>,
+    Array extends boolean = false,
+> = Omit<ModelMutationResult<ModelResult<Schema, Model, TArgs>, TArgs>, 'mutateAsync'> & {
+    mutateAsync<T extends TArgs>(
+        args: T,
+        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+    ): Promise<Array extends true ? ModelResult<Schema, Model, T>[] : ModelResult<Schema, Model, T>>;
+};
+
+export type ClientHooks<Schema extends SchemaDef> = {
+    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model>;
+};
+
+// 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>> = TrimDelegateModelOperations<
+    Schema,
+    Model,
+    {
+        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindFirst<T extends FindArgs<Schema, Model, false>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
+
+        useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
+
+        useCreate<T extends CreateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpdate<T extends UpdateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpsert<T extends UpsertArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useDelete<T extends DeleteArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        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>>;
+
+        useAggregate<T extends AggregateArgs<Schema, Model>>(
+            args: Subset<T, AggregateArgs<Schema, Model>>,
+            options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
+        ): ModelQueryResult<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>>;
+    }
+>;
+
+/**
+ * Gets data query hooks for all models in the schema.
+ */
+export function useClientQueries<Schema extends SchemaDef>(schema: Schema): ClientHooks<Schema> {
+    return Object.keys(schema.models).reduce((acc, model) => {
+        (acc as any)[lowerCaseFirst(model)] = useModelQueries(schema, model as GetModels<Schema>);
+        return acc;
+    }, {} as ClientHooks<Schema>);
+}
+
+/**
+ * Gets data query hooks for a specific model in the schema.
+ */
+export function useModelQueries<Schema extends SchemaDef, Model extends GetModels<Schema>>(
+    schema: Schema,
+    model: Model,
+): ModelQueryHooks<Schema, Model> {
+    const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
+    if (!modelDef) {
+        throw new Error(`Model "${model}" not found in schema`);
+    }
+
+    const modelName = modelDef.name;
+
+    return {
+        useFindUnique: (args: any, options?: any) => {
+            return useInternalQuery(schema, modelName, 'findUnique', args, options);
+        },
+
+        useFindFirst: (args: any, options?: any) => {
+            return useInternalQuery(schema, modelName, 'findFirst', args, options);
+        },
+
+        useFindMany: (args: any, options?: any) => {
+            return useInternalQuery(schema, modelName, 'findMany', args, options);
+        },
+
+        useInfiniteFindMany: (args: any, options?: any) => {
+            return useInternalInfiniteQuery(schema, modelName, 'findMany', args, options);
+        },
+
+        useCreate: (options?: any) => {
+            return useInternalMutation(schema, modelName, 'POST', 'create', options);
+        },
+
+        useCreateMany: (options?: any) => {
+            return useInternalMutation(schema, modelName, 'POST', 'createMany', options);
+        },
+
+        useCreateManyAndReturn: (options?: any) => {
+            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', options);
+        },
+
+        useUpdate: (options?: any) => {
+            return useInternalMutation(schema, modelName, 'PUT', 'update', options);
+        },
+
+        useUpdateMany: (options?: any) => {
+            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', options);
+        },
+
+        useUpdateManyAndReturn: (options?: any) => {
+            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', options);
+        },
+
+        useUpsert: (options?: any) => {
+            return useInternalMutation(schema, modelName, 'POST', 'upsert', options);
+        },
+
+        useDelete: (options?: any) => {
+            return useInternalMutation(schema, modelName, 'DELETE', 'delete', options);
+        },
+
+        useDeleteMany: (options?: any) => {
+            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', options);
+        },
+
+        useCount: (args: any, options?: any) => {
+            return useInternalQuery(schema, modelName, 'count', args, options);
+        },
+
+        useAggregate: (args: any, options?: any) => {
+            return useInternalQuery(schema, modelName, 'aggregate', args, options);
+        },
+
+        useGroupBy: (args: any, options?: any) => {
+            return useInternalQuery(schema, modelName, 'groupBy', args, options);
+        },
+    } as ModelQueryHooks<Schema, Model>;
+}
+
+export function useInternalQuery<TQueryFnData, TData>(
+    _schema: SchemaDef,
+    model: string,
+    operation: string,
+    args?: MaybeRefOrGetter<unknown>,
+    options?: MaybeRefOrGetter<
+        Omit<UnwrapRef<UseQueryOptions<TQueryFnData, DefaultError, TData>>, 'queryKey'> & ExtraQueryOptions
+    >,
+) {
+    const argsValue = toValue(args);
+    const { optimisticUpdate, ...restOptions } = toValue(options) ?? {};
+    const queryKey = getQueryKey(model, operation, argsValue, {
+        infinite: false,
+        optimisticUpdate: optimisticUpdate !== false,
+    });
+    const { endpoint, fetch } = getQuerySettings();
+
+    const finalOptions: any = {
+        queryKey,
+        queryFn: ({ queryKey, signal }: any) => {
+            const [_prefix, _model, _op, args] = queryKey;
+            const reqUrl = makeUrl(endpoint, model, operation, args);
+            return fetcher<TQueryFnData>(reqUrl, { signal }, fetch);
+        },
+        ...restOptions,
+    };
+    return { queryKey, ...useQuery<TQueryFnData, DefaultError, TData>(finalOptions) };
+}
+
+export function useInternalInfiniteQuery<TQueryFnData, TData>(
+    _schema: SchemaDef,
+    model: string,
+    operation: string,
+    args: MaybeRefOrGetter<unknown>,
+    options:
+        | MaybeRefOrGetter<
+              Omit<
+                  UnwrapRef<UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>>,
+                  'queryKey' | 'initialPageParam'
+              >
+          >
+        | undefined,
+) {
+    options = options ?? { getNextPageParam: () => undefined };
+    const { endpoint, fetch } = getQuerySettings();
+    const argsValue = toValue(args);
+    const optionsValue = toValue(options);
+    const queryKey = getQueryKey(model, operation, argsValue, { infinite: true, optimisticUpdate: false });
+
+    const finalOptions: any = {
+        queryKey,
+        queryFn: ({ queryKey, signal }: any) => {
+            const [_prefix, _model, _op, args] = queryKey;
+            const reqUrl = makeUrl(endpoint, model, operation, args);
+            return fetcher<TQueryFnData>(reqUrl, { signal }, fetch);
+        },
+        initialPageParam: argsValue,
+        ...optionsValue,
+    };
+    return {
+        queryKey,
+        ...useInfiniteQuery(finalOptions),
+    };
+}
+
+/**
+ * Creates a vue-query mutation
+ *
+ * @private
+ *
+ * @param model The name of the model under mutation.
+ * @param method The HTTP method.
+ * @param operation The mutation operation (e.g. `create`).
+ * @param options The vue-query options.
+ * @param checkReadBack Whether to check for read back errors and return undefined if found.
+ */
+export function useInternalMutation<TArgs, R = any>(
+    schema: SchemaDef,
+    model: string,
+    method: 'POST' | 'PUT' | 'DELETE',
+    operation: string,
+    options?: MaybeRefOrGetter<
+        Omit<UnwrapRef<UseMutationOptions<R, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions
+    >,
+) {
+    const { endpoint, fetch, logging } = getQuerySettings();
+    const queryClient = useQueryClient();
+    const mutationFn = (data: any) => {
+        const reqUrl =
+            method === 'DELETE' ? makeUrl(endpoint, model, operation, data) : makeUrl(endpoint, model, operation);
+        const fetchInit: RequestInit = {
+            method,
+            ...(method !== 'DELETE' && {
+                headers: {
+                    'content-type': 'application/json',
+                },
+                body: marshal(data),
+            }),
+        };
+        return fetcher<R>(reqUrl, fetchInit, fetch) as Promise<R>;
+    };
+
+    const optionsValue = toValue(options);
+    const finalOptions: any = { ...optionsValue, mutationFn };
+    const invalidateQueries = optionsValue?.invalidateQueries !== false;
+    const optimisticUpdate = !!optionsValue?.optimisticUpdate;
+
+    if (operation) {
+        if (invalidateQueries) {
+            setupInvalidation(
+                model,
+                operation,
+                schema,
+                finalOptions,
+                (predicate) => queryClient.invalidateQueries({ predicate }),
+                logging,
+            );
+        }
+
+        if (optimisticUpdate) {
+            setupOptimisticUpdate(
+                model,
+                operation,
+                schema,
+                finalOptions,
+                queryClient.getQueryCache().getAll(),
+                (queryKey, data) => {
+                    // update query cache
+                    queryClient.setQueryData<unknown>(queryKey, data);
+                    // cancel on-flight queries to avoid redundant cache updates,
+                    // the settlement of the current mutation will trigger a new revalidation
+                    queryClient.cancelQueries({ queryKey }, { revert: false, silent: true });
+                },
+                invalidateQueries ? (predicate) => queryClient.invalidateQueries({ predicate }) : undefined,
+                logging,
+            );
+        }
+    }
+
+    return useMutation(finalOptions);
+}

package/test/react-typing-test.ts

@@ -0,0 +1,109 @@
+import { useClientQueries } from '../src/react';
+import { schema } from './schemas/basic/schema-lite';
+
+const client = useClientQueries(schema);
+
+// @ts-expect-error missing args
+client.user.useFindUnique();
+
+check(client.user.useFindUnique({ where: { id: '1' } }).data?.email);
+check(client.user.useFindUnique({ where: { id: '1' } }).queryKey);
+check(client.user.useFindUnique({ where: { id: '1' } }, { optimisticUpdate: true, enabled: false }));
+
+// @ts-expect-error unselected field
+check(client.user.useFindUnique({ select: { email: true } }).data.name);
+
+check(client.user.useFindUnique({ where: { id: '1' }, include: { posts: true } }).data?.posts[0]?.title);
+
+check(client.user.useFindFirst().data?.email);
+
+check(client.user.useFindMany().data?.[0]?.email);
+
+check(client.user.useInfiniteFindMany().data?.pages[0]?.[0]?.email);
+check(
+    client.user.useInfiniteFindMany(
+        {},
+        {
+            getNextPageParam: () => ({ id: '2' }),
+        },
+    ).data?.pages[1]?.[0]?.email,
+);
+
+check(client.user.useSuspenseFindMany().data[0]?.email);
+check(client.user.useSuspenseInfiniteFindMany().data.pages[0]?.[0]?.email);
+check(client.user.useCount().data?.toFixed(2));
+check(client.user.useCount({ select: { email: true } }).data?.email.toFixed(2));
+
+check(client.user.useAggregate({ _max: { email: true } }).data?._max.email);
+
+check(client.user.useGroupBy({ by: ['email'], _max: { name: true } }).data?.[0]?._max.name);
+
+// @ts-expect-error missing args
+client.user.useCreate().mutate();
+client.user.useCreate().mutate({ data: { email: 'test@example.com' } });
+client.user
+    .useCreate({ optimisticUpdate: true, invalidateQueries: false, retry: 3 })
+    .mutate({ data: { email: 'test@example.com' } });
+
+client.user
+    .useCreate()
+    .mutateAsync({ data: { email: 'test@example.com' }, include: { posts: true } })
+    .then((d) => check(d.posts[0]?.title));
+
+client.user
+    .useCreateMany()
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }, { email: 'test2@example.com' }],
+        skipDuplicates: true,
+    })
+    .then((d) => d.count);
+
+client.user
+    .useCreateManyAndReturn()
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+    })
+    .then((d) => check(d[0]?.name));
+
+client.user
+    .useCreateManyAndReturn()
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+        select: { email: true },
+    })
+    // @ts-expect-error unselected field
+    .then((d) => check(d[0].name));
+
+client.user.useUpdate().mutate(
+    { data: { email: 'updated@example.com' }, where: { id: '1' } },
+    {
+        onSuccess: (d) => {
+            check(d.email);
+        },
+    },
+);
+
+client.user.useUpdateMany().mutate({ data: { email: 'updated@example.com' } });
+
+client.user
+    .useUpdateManyAndReturn()
+    .mutateAsync({ data: { email: 'updated@example.com' } })
+    .then((d) => check(d[0]?.email));
+
+client.user
+    .useUpsert()
+    .mutate({ where: { id: '1' }, create: { email: 'new@example.com' }, update: { email: 'updated@example.com' } });
+
+client.user.useDelete().mutate({ where: { id: '1' }, include: { posts: true } });
+
+client.user.useDeleteMany().mutate({ where: { email: 'test@example.com' } });
+
+function check(_value: unknown) {
+    // noop
+}
+
+// @ts-expect-error delegate model
+client.foo.useCreate();
+
+client.foo.useUpdate();
+client.bar.useCreate();

package/test/schemas/basic/input.ts

@@ -68,3 +68,43 @@ export type CategorySelect = $SelectInput<$Schema, "Category">;
 export type CategoryInclude = $IncludeInput<$Schema, "Category">;
 export type CategoryOmit = $OmitInput<$Schema, "Category">;
 export type CategoryGetPayload<Args extends $SelectIncludeOmit<$Schema, "Category", true>> = $SimplifiedModelResult<$Schema, "Category", Args>;
+export type FooFindManyArgs = $FindManyArgs<$Schema, "Foo">;
+export type FooFindUniqueArgs = $FindUniqueArgs<$Schema, "Foo">;
+export type FooFindFirstArgs = $FindFirstArgs<$Schema, "Foo">;
+export type FooCreateArgs = $CreateArgs<$Schema, "Foo">;
+export type FooCreateManyArgs = $CreateManyArgs<$Schema, "Foo">;
+export type FooCreateManyAndReturnArgs = $CreateManyAndReturnArgs<$Schema, "Foo">;
+export type FooUpdateArgs = $UpdateArgs<$Schema, "Foo">;
+export type FooUpdateManyArgs = $UpdateManyArgs<$Schema, "Foo">;
+export type FooUpdateManyAndReturnArgs = $UpdateManyAndReturnArgs<$Schema, "Foo">;
+export type FooUpsertArgs = $UpsertArgs<$Schema, "Foo">;
+export type FooDeleteArgs = $DeleteArgs<$Schema, "Foo">;
+export type FooDeleteManyArgs = $DeleteManyArgs<$Schema, "Foo">;
+export type FooCountArgs = $CountArgs<$Schema, "Foo">;
+export type FooAggregateArgs = $AggregateArgs<$Schema, "Foo">;
+export type FooGroupByArgs = $GroupByArgs<$Schema, "Foo">;
+export type FooWhereInput = $WhereInput<$Schema, "Foo">;
+export type FooSelect = $SelectInput<$Schema, "Foo">;
+export type FooInclude = $IncludeInput<$Schema, "Foo">;
+export type FooOmit = $OmitInput<$Schema, "Foo">;
+export type FooGetPayload<Args extends $SelectIncludeOmit<$Schema, "Foo", true>> = $SimplifiedModelResult<$Schema, "Foo", Args>;
+export type BarFindManyArgs = $FindManyArgs<$Schema, "Bar">;
+export type BarFindUniqueArgs = $FindUniqueArgs<$Schema, "Bar">;
+export type BarFindFirstArgs = $FindFirstArgs<$Schema, "Bar">;
+export type BarCreateArgs = $CreateArgs<$Schema, "Bar">;
+export type BarCreateManyArgs = $CreateManyArgs<$Schema, "Bar">;
+export type BarCreateManyAndReturnArgs = $CreateManyAndReturnArgs<$Schema, "Bar">;
+export type BarUpdateArgs = $UpdateArgs<$Schema, "Bar">;
+export type BarUpdateManyArgs = $UpdateManyArgs<$Schema, "Bar">;
+export type BarUpdateManyAndReturnArgs = $UpdateManyAndReturnArgs<$Schema, "Bar">;
+export type BarUpsertArgs = $UpsertArgs<$Schema, "Bar">;
+export type BarDeleteArgs = $DeleteArgs<$Schema, "Bar">;
+export type BarDeleteManyArgs = $DeleteManyArgs<$Schema, "Bar">;
+export type BarCountArgs = $CountArgs<$Schema, "Bar">;
+export type BarAggregateArgs = $AggregateArgs<$Schema, "Bar">;
+export type BarGroupByArgs = $GroupByArgs<$Schema, "Bar">;
+export type BarWhereInput = $WhereInput<$Schema, "Bar">;
+export type BarSelect = $SelectInput<$Schema, "Bar">;
+export type BarInclude = $IncludeInput<$Schema, "Bar">;
+export type BarOmit = $OmitInput<$Schema, "Bar">;
+export type BarGetPayload<Args extends $SelectIncludeOmit<$Schema, "Bar", true>> = $SimplifiedModelResult<$Schema, "Bar", Args>;

package/test/schemas/basic/models.ts

@@ -10,3 +10,5 @@ import { type ModelResult as $ModelResult } from "@zenstackhq/orm";
 export type User = $ModelResult<$Schema, "User">;
 export type Post = $ModelResult<$Schema, "Post">;
 export type Category = $ModelResult<$Schema, "Category">;
+export type Foo = $ModelResult<$Schema, "Foo">;
+export type Bar = $ModelResult<$Schema, "Bar">;

package/test/schemas/basic/schema-lite.ts

@@ -116,6 +116,54 @@ export const schema = {
                 id: { type: "String" },
                 name: { type: "String" }
             }
+        },
+        Foo: {
+            name: "Foo",
+            fields: {
+                id: {
+                    name: "id",
+                    type: "String",
+                    id: true,
+                    default: ExpressionUtils.call("cuid")
+                },
+                type: {
+                    name: "type",
+                    type: "String",
+                    isDiscriminator: true
+                }
+            },
+            idFields: ["id"],
+            uniqueFields: {
+                id: { type: "String" }
+            },
+            isDelegate: true,
+            subModels: ["Bar"]
+        },
+        Bar: {
+            name: "Bar",
+            baseModel: "Foo",
+            fields: {
+                id: {
+                    name: "id",
+                    type: "String",
+                    id: true,
+                    default: ExpressionUtils.call("cuid")
+                },
+                type: {
+                    name: "type",
+                    type: "String",
+                    originModel: "Foo",
+                    isDiscriminator: true
+                },
+                title: {
+                    name: "title",
+                    type: "String"
+                }
+            },
+            idFields: ["id"],
+            uniqueFields: {
+                id: { type: "String" }
+            }
         }
     },
     authType: "User",

package/test/schemas/basic/schema.zmodel

@@ -22,4 +22,14 @@ model Category {
     id    String   @id @default(cuid())
     name  String   @unique
     posts Post[]
-}
+}
+
+model Foo {
+    id String @id @default(cuid())
+    type String
+    @@delegate(type)
+}
+
+model Bar extends Foo {
+    title String
+}