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

package/test/svelte-typing-test.ts

@@ -0,0 +1,111 @@
+import { get } from 'svelte/store';
+import { useClientQueries } from '../src/svelte';
+import { schema } from './schemas/basic/schema-lite';
+
+const client = useClientQueries(schema);
+
+// @ts-expect-error missing args
+client.user.useFindUnique();
+
+check(get(client.user.useFindUnique({ where: { id: '1' } })).data?.email);
+check(get(client.user.useFindUnique({ where: { id: '1' } })).queryKey);
+check(get(client.user.useFindUnique({ where: { id: '1' } }, { optimisticUpdate: true, enabled: false })));
+
+// @ts-expect-error unselected field
+check(get(client.user.useFindUnique({ select: { email: true } })).data.name);
+
+check(get(client.user.useFindUnique({ where: { id: '1' }, include: { posts: true } })).data?.posts[0]?.title);
+
+check(get(client.user.useFindFirst()).data?.email);
+check(get(client.user.useFindFirst()).data?.$optimistic);
+
+check(get(client.user.useFindMany()).data?.[0]?.email);
+check(get(client.user.useFindMany()).data?.[0]?.$optimistic);
+
+check(get(client.user.useInfiniteFindMany()).data?.pages[0]?.[0]?.email);
+check(
+    get(
+        client.user.useInfiniteFindMany(
+            {},
+            {
+                getNextPageParam: () => ({ id: '2' }),
+            },
+        ),
+    ).data?.pages[1]?.[0]?.email,
+);
+// @ts-expect-error
+check(get(client.user.useInfiniteFindMany()).data?.pages[0]?.[0]?.$optimistic);
+
+check(get(client.user.useCount()).data?.toFixed(2));
+check(get(client.user.useCount({ select: { email: true } })).data?.email.toFixed(2));
+
+check(get(client.user.useAggregate({ _max: { email: true } })).data?._max.email);
+
+check(get(client.user.useGroupBy({ by: ['email'], _max: { name: true } })).data?.[0]?._max.name);
+
+// @ts-expect-error missing args
+client.user.useCreate().mutate();
+get(client.user.useCreate()).mutate({ data: { email: 'test@example.com' } });
+get(client.user.useCreate({ optimisticUpdate: true, invalidateQueries: false, retry: 3 })).mutate({
+    data: { email: 'test@example.com' },
+});
+
+get(client.user.useCreate())
+    .mutateAsync({ data: { email: 'test@example.com' }, include: { posts: true } })
+    .then((d) => check(d.posts[0]?.title));
+
+get(client.user.useCreateMany())
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }, { email: 'test2@example.com' }],
+        skipDuplicates: true,
+    })
+    .then((d) => d.count);
+
+get(client.user.useCreateManyAndReturn())
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+    })
+    .then((d) => check(d[0]?.name));
+
+get(client.user.useCreateManyAndReturn())
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+        select: { email: true },
+    })
+    // @ts-expect-error unselected field
+    .then((d) => check(d[0].name));
+
+get(client.user.useUpdate()).mutate(
+    { data: { email: 'updated@example.com' }, where: { id: '1' } },
+    {
+        onSuccess: (d) => {
+            check(d.email);
+        },
+    },
+);
+
+get(client.user.useUpdateMany()).mutate({ data: { email: 'updated@example.com' } });
+
+get(client.user.useUpdateManyAndReturn())
+    .mutateAsync({ data: { email: 'updated@example.com' } })
+    .then((d) => check(d[0]?.email));
+
+get(client.user.useUpsert()).mutate({
+    where: { id: '1' },
+    create: { email: 'new@example.com' },
+    update: { email: 'updated@example.com' },
+});
+
+get(client.user.useDelete()).mutate({ where: { id: '1' }, include: { posts: true } });
+
+get(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/vue-typing-test.ts

@@ -0,0 +1,111 @@
+import { useClientQueries } from '../src/vue';
+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.value?.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.value?.posts[0]?.title);
+
+check(client.user.useFindFirst().data.value?.email);
+check(client.user.useFindFirst().data.value?.$optimistic);
+
+check(client.user.useFindMany().data.value?.[0]?.email);
+check(client.user.useFindMany().data.value?.[0]?.$optimistic);
+
+check(client.user.useInfiniteFindMany().data.value?.pages[0]?.[0]?.email);
+check(
+    client.user.useInfiniteFindMany(
+        {},
+        {
+            getNextPageParam: () => ({ id: '2' }),
+        },
+    ).data.value?.pages[1]?.[0]?.email,
+);
+// @ts-expect-error
+check(client.user.useInfiniteFindMany().data.value?.pages[0]?.[0]?.$optimistic);
+
+check(client.user.useCount().data.value?.toFixed(2));
+check(client.user.useCount({ select: { email: true } }).data.value?.email.toFixed(2));
+
+check(client.user.useAggregate({ _max: { email: true } }).data.value?._max.email);
+
+check(client.user.useGroupBy({ by: ['email'], _max: { name: true } }).data.value?.[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/tsup.config.ts

@@ -3,6 +3,8 @@ import { defineConfig } from 'tsup';
 export default defineConfig({
     entry: {
         react: 'src/react.ts',
+        vue: 'src/vue.ts',
+        svelte: 'src/svelte.ts',
     },
     outDir: 'dist',
     splitting: false,