@bg-dev/nuxt-zenstack 0.0.3 → 0.0.5

package/dist/runtime/composables/useZenstackRealtime/index.js

@@ -0,0 +1,53 @@
+import { useZenstackStore } from "../useZenstackStore/index.js";
+import { useZenstackRead } from "../useZenstackRead/index.js";
+import destr from "destr";
+import { joinURL } from "ufo";
+import { getConfig } from "../common.js";
+export function useZenstackRealtime() {
+  const config = getConfig();
+  const url = joinURL(config.baseUrl, config.apiPath, "realtime");
+  const subscriptions = /* @__PURE__ */ new Set();
+  let eventSource = null;
+  function connect() {
+    if (eventSource)
+      return;
+    eventSource = new EventSource(url);
+    eventSource.onmessage = (event) => {
+      const data = destr(event.data);
+      if (data)
+        onMessage(data);
+    };
+  }
+  async function onMessage(data) {
+    if (!subscriptions.has(data.model))
+      return;
+    for (const id of data.ids) {
+      if (data.action === "delete") {
+        useZenstackStore().deleteOne(data.model, id);
+      } else {
+        await useZenstackRead(data.model, id, { fetchPolicy: "fetch-only" });
+      }
+    }
+  }
+  function disconnect() {
+    if (eventSource)
+      eventSource.close();
+    eventSource = null;
+  }
+  function subscribe(models) {
+    for (const model of models)
+      subscriptions.add(model);
+    if (subscriptions.size > 0)
+      connect();
+  }
+  function unsubscribe(models) {
+    for (const model of models)
+      subscriptions.delete(model);
+    if (subscriptions.size === 0)
+      disconnect();
+  }
+  function getSubscriptions() {
+    return Array.from(subscriptions);
+  }
+  return { subscribe, unsubscribe, getSubscriptions };
+}

package/dist/runtime/composables/useZenstackStore/index.d.ts

@@ -11,11 +11,15 @@ type FetchEntry = {
 export declare function useZenstackStore(): {
     state: Readonly<import("vue").Ref<{
         readonly [x: string]: {
-            readonly [x: string]: object;
+            readonly [x: string]: {
+                readonly [x: string]: string | number | boolean | readonly string[] | null;
+            };
         };
     }, {
         readonly [x: string]: {
-            readonly [x: string]: object;
+            readonly [x: string]: {
+                readonly [x: string]: string | number | boolean | readonly string[] | null;
+            };
         };
     }>>;
     fetchHistory: Readonly<import("vue").Ref<readonly {

package/dist/runtime/composables/useZenstackStore/index.js

@@ -1,6 +1,5 @@
-import { generateNormalizrSchema, getNormalizrSchema } from "./normalization.js";
+import { generateNormalizrSchema, getNormalizrSchema, mergeNormalizedData } from "./normalization.js";
 import { normalize, denormalize } from "normalizr";
-import { defu } from "defu";
 import { readonly, useState } from "#imports";
 generateNormalizrSchema();
 export function useZenstackStore() {
@@ -9,12 +8,12 @@ export function useZenstackStore() {
   function setOne(model, input) {
     const schema = getNormalizrSchema(model);
     const res = normalize(input, schema);
-    state.value = defu(res.entities, state.value);
+    state.value = mergeNormalizedData(res.entities, state.value);
   }
   function setMany(model, input) {
     const schema = [getNormalizrSchema(model)];
     const res = normalize(input, schema);
-    state.value = defu(res.entities, state.value);
+    state.value = mergeNormalizedData(res.entities, state.value);
   }
   function getOne(model, input) {
     const schema = getNormalizrSchema(model);

package/dist/runtime/composables/useZenstackStore/normalization.d.ts

@@ -1,5 +1,18 @@
 import { schema as normalizrSchema } from 'normalizr';
 import type { $Zmodel } from '#build/types/nuxt-zenstack';
-declare function getNormalizrSchema(model: $Zmodel): normalizrSchema.Entity<any>;
-declare function generateNormalizrSchema(): void;
-export { getNormalizrSchema, generateNormalizrSchema };
+type NormalizedDataField = number | string | boolean | null | string[];
+/**
+ * Normalized data structure
+ * {
+ *   model: {
+ *     id: {
+ *       field: NormalizedDataField
+ *     }
+ *   }
+ * }
+ */
+export type NormalizedData = Record<string, Record<string, Record<string, NormalizedDataField>>>;
+export declare function getNormalizrSchema(model: $Zmodel): normalizrSchema.Entity<any>;
+export declare function generateNormalizrSchema(): void;
+export declare function mergeNormalizedData(newData: NormalizedData, currentData: NormalizedData): NormalizedData;
+export {};

package/dist/runtime/composables/useZenstackStore/normalization.js

@@ -1,13 +1,14 @@
 import { schema as normalizrSchema } from "normalizr";
 import { getModelDef, getModels, isValidModel } from "./helpers.js";
+import { defu } from "defu";
 const NORMALIZR_SCHEMA = /* @__PURE__ */ new Map();
-function getNormalizrSchema(model) {
+export function getNormalizrSchema(model) {
   const schema = NORMALIZR_SCHEMA.get(model);
   if (!schema)
     throw new Error(`Model ${model.toString()} not defined`);
   return schema;
 }
-function generateNormalizrSchema() {
+export function generateNormalizrSchema() {
   const models = getModels();
   for (const model of models) {
     NORMALIZR_SCHEMA.set(model, new normalizrSchema.Entity(model.toString()));
@@ -28,4 +29,16 @@ function generateNormalizrSchema() {
     }
   }
 }
-export { getNormalizrSchema, generateNormalizrSchema };
+export function mergeNormalizedData(newData, currentData) {
+  const merged = defu(newData, currentData);
+  for (const model in merged) {
+    for (const id in merged[model]) {
+      for (const field in merged[model][id]) {
+        if (Array.isArray(merged[model][id][field])) {
+          merged[model][id][field] = Array.from(new Set(merged[model][id][field]));
+        }
+      }
+    }
+  }
+  return merged;
+}

package/dist/runtime/composables/useZenstackUpdate/index.d.ts

@@ -1,9 +1,9 @@
-import type { $Zmodel, $Zitem, $ZupdateData, $Zid } from '#build/types/nuxt-zenstack';
+import type { $Zmodel, $Zitem, $ZupdateData, $Zid, $Zerror } from '#build/types/nuxt-zenstack';
 import type { Status } from '../common.js';
 import type { Ref } from '#imports';
 export declare function useZenstackUpdate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;
-    error: Ref<Error | null>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     mutate: (id: $Zid<Zmodel>, input: $ZupdateData<Zmodel>) => Promise<void>;
     reset: () => void;

package/dist/runtime/server/api/models/[model]/[id].delete.d.ts

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     data: {
         [x: string]: any;
-    };
+    } & {};
 }>>;
 export default _default;

package/dist/runtime/server/api/models/[model]/[id].delete.js

@@ -1,14 +1,10 @@
 import { defineEventHandler } from "h3";
-import { parseModel, parseId } from "../../../utils/parsers.js";
-import { getModelOperations } from "../../../utils/index.js";
+import { parseModel, parseId, parseClient } from "../../../utils/parsers.js";
+import { useZenstack } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
+  const client = parseClient(event);
   const model = parseModel(event);
   const id = parseId(event, model);
-  const operations = getModelOperations(model);
-  const data = await operations.delete({
-    where: {
-      id
-    }
-  });
-  return { data };
+  const zenstack = useZenstack();
+  return zenstack.delete({ client, model, id });
 });

package/dist/runtime/server/api/models/[model]/[id].get.d.ts

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     data: {
         [x: string]: any;
-    } | null;
+    } & {};
 }>>;
 export default _default;

package/dist/runtime/server/api/models/[model]/[id].get.js

@@ -1,16 +1,11 @@
-import { parseModel, parseId, parseReadArgs } from "../../../utils/parsers.js";
+import { parseModel, parseId, parseReadArgs, parseClient } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../../utils/index.js";
+import { useZenstack } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
+  const client = parseClient(event);
   const model = parseModel(event);
   const id = parseId(event, model);
   const readArgs = parseReadArgs(event, model);
-  const operations = getModelOperations(model);
-  const data = await operations.findUnique({
-    include: readArgs.include,
-    where: {
-      id
-    }
-  });
-  return { data };
+  const zenstack = useZenstack();
+  return zenstack.findUnique({ client, model, id, include: readArgs.include });
 });

package/dist/runtime/server/api/models/[model]/[id].patch.d.ts

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     data: {
         [x: string]: any;
-    };
+    } & {};
 }>>;
 export default _default;

package/dist/runtime/server/api/models/[model]/[id].patch.js

@@ -1,18 +1,11 @@
-import { parseModel, parseId, parseUpdateData } from "../../../utils/parsers.js";
+import { parseModel, parseId, parseUpdateArgs, parseClient } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations, includeAll } from "../../../utils/index.js";
+import { useZenstack } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
+  const client = parseClient(event);
   const model = parseModel(event);
   const id = parseId(event, model);
-  const updateData = await parseUpdateData(event, model);
-  const operations = getModelOperations(model);
-  const include = includeAll(model);
-  const data = await operations.update({
-    data: updateData.data,
-    include,
-    where: {
-      id
-    }
-  });
-  return { data };
+  const updateArgs = await parseUpdateArgs(event, model);
+  const zenstack = useZenstack();
+  return zenstack.update({ client, model, id, data: updateArgs.data });
 });

package/dist/runtime/server/api/models/[model]/index.get.d.ts

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    data: {
+    data: ({
         [x: string]: any;
-    }[];
+    } & {})[];
 }>>;
 export default _default;

package/dist/runtime/server/api/models/[model]/index.get.js

@@ -1,16 +1,18 @@
-import { parseModel, parseReadArgs } from "../../../utils/parsers.js";
+import { parseClient, parseModel, parseReadArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../../utils/index.js";
+import { useZenstack } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
+  const client = parseClient(event);
   const model = parseModel(event);
   const readArgs = parseReadArgs(event, model);
-  const operations = getModelOperations(model);
-  const data = await operations.findMany({
-    orderBy: readArgs.orderBy,
-    include: readArgs.include,
+  const zenstack = useZenstack();
+  return zenstack.findMany({
+    client,
+    model,
     skip: readArgs.skip,
     take: readArgs.take,
+    include: readArgs.include,
+    orderBy: readArgs.orderBy,
     where: readArgs.where
   });
-  return { data };
 });

package/dist/runtime/server/api/models/[model]/index.post.d.ts

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     data: {
         [x: string]: any;
-    };
+    } & {};
 }>>;
 export default _default;

package/dist/runtime/server/api/models/[model]/index.post.js

@@ -1,14 +1,10 @@
-import { parseModel, parseCreateData } from "../../../utils/parsers.js";
+import { parseModel, parseCreateArgs, parseClient } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations, includeAll } from "../../../utils/index.js";
+import { useZenstack } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
+  const client = parseClient(event);
   const model = parseModel(event);
-  const createData = await parseCreateData(event, model);
-  const operations = getModelOperations(model);
-  const include = includeAll(model);
-  const data = await operations.create({
-    data: createData.data,
-    include
-  });
-  return { data };
+  const createArgs = await parseCreateArgs(event, model);
+  const zenstack = useZenstack();
+  return zenstack.create({ client, model, data: createArgs.data });
 });

package/dist/runtime/server/routes/realtime.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/routes/realtime.js

@@ -0,0 +1,18 @@
+import { defineEventHandler, createEventStream } from "h3";
+import { useNitroApp } from "nitropack/runtime";
+export default defineEventHandler(async (event) => {
+  const eventStream = createEventStream(event);
+  const nitroApp = useNitroApp();
+  nitroApp.hooks.hook("zenstack:after_mutation", (action, model, items) => {
+    const message = {
+      model,
+      action,
+      ids: items.map((item) => item.id)
+    };
+    eventStream.push(JSON.stringify(message));
+  });
+  eventStream.onClosed(async () => {
+    await eventStream.close();
+  });
+  return eventStream.send();
+});

package/dist/runtime/server/utils/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { $Zmodel, $Zdef, $ZcreateData, $ZupdateData } from '#build/types/nuxt-zenstack';
+export declare function getModelDef(model: $Zmodel): $Zdef;
+export declare function isIdString(model: $Zmodel): boolean;
+export declare function getModels(): $Zmodel[];
+export declare function isValidModel(model: $Zmodel): boolean;
+export declare function sanitizeCreateData<Zmodel extends $Zmodel>(model: Zmodel, data: $ZcreateData<Zmodel>): $ZcreateData<Zmodel>;
+export declare function sanitizeUpdateData<Zmodel extends $Zmodel>(model: Zmodel, data: $ZupdateData<Zmodel>): $ZupdateData<Zmodel>;

package/dist/runtime/server/utils/helpers.js

@@ -0,0 +1,34 @@
+import { zenstackSchema } from "nuxt-zenstack-server.mjs";
+export function getModelDef(model) {
+  return zenstackSchema.models[model];
+}
+export function isIdString(model) {
+  const modelDef = getModelDef(model);
+  if (!modelDef.uniqueFields.id)
+    throw new Error(`Model ${model.toString()} does not have an id as a unique field`);
+  return modelDef.uniqueFields.id.type === "String";
+}
+export function getModels() {
+  return Object.keys(zenstackSchema.models);
+}
+export function isValidModel(model) {
+  return getModels().includes(model);
+}
+function getRelationalFields(model) {
+  const modelDef = getModelDef(model);
+  return Object.entries(modelDef.fields).filter(([_field, fieldDef]) => isValidModel(fieldDef.type)).map(([field]) => field);
+}
+export function sanitizeCreateData(model, data) {
+  const relationalFields = getRelationalFields(model);
+  relationalFields.forEach((field) => {
+    data[field] = void 0;
+  });
+  return data;
+}
+export function sanitizeUpdateData(model, data) {
+  const relationalFields = getRelationalFields(model);
+  relationalFields.forEach((field) => {
+    data[field] = void 0;
+  });
+  return data;
+}

package/dist/runtime/server/utils/index.d.ts

@@ -1,12 +1,15 @@
-import type { ClientContract } from '@zenstackhq/orm';
-import type { $Zschema, $Zmodel, $Zoperations, $Zdef } from '#build/types/nuxt-zenstack';
-declare let _client: ClientContract<$Zschema> | null;
-export declare function provideClient(client: typeof _client): void;
-export declare function getClient(): ClientContract<SchemaType>;
-export declare function getModelOperations<Zmodel extends $Zmodel>(model: Zmodel): $Zoperations<Zmodel>;
-export declare function getModelDef(model: $Zmodel): $Zdef;
-export declare function isIdString(model: $Zmodel): boolean;
-export declare function getModels(): $Zmodel[];
-export declare function isValidModel(model: $Zmodel): boolean;
-export declare function includeAll<Zmodel extends $Zmodel>(model: Zmodel): boolean | import("@zenstackhq/orm").SelectIncludeOmit<SchemaType, any, boolean, true>;
-export {};
+import { _delete } from './operations/delete.js';
+import { update } from './operations/update.js';
+import { findUnique } from './operations/findUnique.js';
+import { findMany } from './operations/findMany.js';
+import { create } from './operations/create.js';
+import type { $Zclient } from '#build/types/nuxt-zenstack';
+import type { H3Event } from 'h3';
+export declare function useZenstack(): {
+    delete: typeof _delete;
+    update: typeof update;
+    findUnique: typeof findUnique;
+    findMany: typeof findMany;
+    create: typeof create;
+    setSessionClient: (event: H3Event, client: $Zclient) => void;
+};

package/dist/runtime/server/utils/index.js

@@ -1,48 +1,14 @@
-import { zenstackSchema } from "nuxt-zenstack-server.mjs";
-let _client = null;
-export function provideClient(client) {
-  _client = client;
-}
-export function getClient() {
-  if (_client) {
-    return _client;
-  }
-  throw new Error("ZenStack client not provided");
-}
-export function getModelOperations(model) {
-  const db = getClient();
-  return db[model.toString().toLocaleLowerCase()];
-}
-export function getModelDef(model) {
-  return zenstackSchema.models[model];
-}
-export function isIdString(model) {
-  const modelDef = getModelDef(model);
-  if (!modelDef.uniqueFields.id)
-    throw new Error(`Model ${model.toString()} does not have an id as a unique field`);
-  return modelDef.uniqueFields.id.type === "String";
-}
-export function getModels() {
-  return Object.keys(zenstackSchema.models);
-}
-export function isValidModel(model) {
-  return getModels().includes(model);
-}
-export function includeAll(model) {
-  const include = {};
-  const modelSet = /* @__PURE__ */ new Set();
-  function iterate(_model, acc) {
-    const modelDef = getModelDef(_model);
-    for (const [field, fieldDef] of Object.entries(modelDef.fields)) {
-      if (isValidModel(fieldDef.type) && !modelSet.has(fieldDef.type)) {
-        acc["include"] ||= {};
-        acc["include"][field] = {};
-        modelSet.add(fieldDef.type);
-        iterate(fieldDef.type, acc["include"][field]);
-      }
-    }
+import { _delete } from "./operations/delete.js";
+import { update } from "./operations/update.js";
+import { findUnique } from "./operations/findUnique.js";
+import { findMany } from "./operations/findMany.js";
+import { create } from "./operations/create.js";
+export function useZenstack() {
+  function setSessionClient(event, client) {
+    if (event.context.zenstack)
+      event.context.zenstack.client = client;
+    else
+      event.context.zenstack = { client };
   }
-  modelSet.add(model);
-  iterate(model, include);
-  return include["include"] ?? {};
+  return { delete: _delete, update, findUnique, findMany, create, setSessionClient };
 }

package/dist/runtime/server/utils/operations/common.d.ts

@@ -0,0 +1,10 @@
+import type { $Zmodel, $Zoperations, $Zclient, $ZormError } from '#build/types/nuxt-zenstack';
+import { ORMErrorReason } from '@zenstackhq/orm';
+export declare function createError(ormError: $ZormError): import("h3").H3Error<{
+    ormErrorReason: ORMErrorReason;
+    dbErrorCode?: unknown;
+    dbErrorMessage?: string;
+    model?: string;
+    rejectedByPolicyReason?: import("@zenstackhq/orm").RejectedByPolicyReason;
+}>;
+export declare function getModelOperations<Zmodel extends $Zmodel>(client: $Zclient, model: Zmodel): $Zoperations<Zmodel>;

package/dist/runtime/server/utils/operations/common.js

@@ -0,0 +1,52 @@
+import { ORMErrorReason } from "@zenstackhq/orm";
+import { createError as createH3Error } from "h3";
+export function createError(ormError) {
+  let statusCode = 500;
+  switch (ormError.reason) {
+    case ORMErrorReason.CONFIG_ERROR:
+      statusCode = 500;
+      break;
+    case ORMErrorReason.DB_QUERY_ERROR:
+      statusCode = 409;
+      break;
+    case ORMErrorReason.INTERNAL_ERROR:
+      statusCode = 500;
+      break;
+    case ORMErrorReason.NOT_FOUND:
+      statusCode = 404;
+      break;
+    case ORMErrorReason.INVALID_INPUT:
+      statusCode = 400;
+      break;
+    case ORMErrorReason.NOT_SUPPORTED:
+      statusCode = 501;
+      break;
+    case ORMErrorReason.REJECTED_BY_POLICY:
+      statusCode = 401;
+      break;
+    default:
+      statusCode = 500;
+  }
+  const error = {
+    name: "Zenstack Error",
+    cause: ormError.cause,
+    message: ormError.message,
+    statusCode,
+    statusMessage: ormError.reason,
+    stack: ormError.stack,
+    fatal: false,
+    unhandled: false,
+    toJSON: () => error,
+    data: {
+      ormErrorReason: ormError.reason,
+      dbErrorCode: ormError.dbErrorCode,
+      dbErrorMessage: ormError.dbErrorMessage,
+      model: ormError.model,
+      rejectedByPolicyReason: ormError.rejectedByPolicyReason
+    }
+  };
+  return createH3Error(error);
+}
+export function getModelOperations(client, model) {
+  return client[model.toString().toLocaleLowerCase()];
+}

package/dist/runtime/server/utils/operations/create.d.ts

@@ -0,0 +1,10 @@
+import type { $Zclient, $Zmodel, $ZcreateData, $Zitem } from '#build/types/nuxt-zenstack';
+type CreateArgs<Zmodel extends $Zmodel> = {
+    client: $Zclient;
+    model: Zmodel;
+    data: $ZcreateData<Zmodel>;
+};
+export declare function create<Zmodel extends $Zmodel>(args: CreateArgs<Zmodel>): Promise<{
+    data: $Zitem<Zmodel>;
+}>;
+export {};

package/dist/runtime/server/utils/operations/create.js

@@ -0,0 +1,15 @@
+import { getModelOperations, createError } from "./common.js";
+import { sanitizeCreateData } from "../helpers.js";
+import { useNitroApp } from "nitropack/runtime";
+export async function create(args) {
+  const operations = getModelOperations(args.client, args.model);
+  const sanitizedData = sanitizeCreateData(args.model, args.data);
+  const data = await operations.create({
+    data: sanitizedData
+  }).catch((err) => {
+    throw createError(err);
+  });
+  const nitroApp = useNitroApp();
+  await nitroApp.hooks.callHook("zenstack:after_mutation", "create", args.model, [data]);
+  return { data };
+}

package/dist/runtime/server/utils/operations/delete.d.ts

@@ -0,0 +1,10 @@
+import type { $Zclient, $Zmodel, $Zid, $Zitem } from '#build/types/nuxt-zenstack';
+type DeleteArgs<Zmodel extends $Zmodel> = {
+    client: $Zclient;
+    model: Zmodel;
+    id: $Zid<Zmodel>;
+};
+export declare function _delete<Zmodel extends $Zmodel>(args: DeleteArgs<Zmodel>): Promise<{
+    data: $Zitem<Zmodel>;
+}>;
+export {};

package/dist/runtime/server/utils/operations/delete.js

@@ -0,0 +1,16 @@
+import { getModelOperations, createError } from "./common.js";
+import { useNitroApp } from "nitropack/runtime";
+export async function _delete(args) {
+  const operations = getModelOperations(args.client, args.model);
+  const data = await operations.delete({
+    // @ts-expect-error id not known here
+    where: {
+      id: args.id
+    }
+  }).catch((err) => {
+    throw createError(err);
+  });
+  const nitroApp = useNitroApp();
+  await nitroApp.hooks.callHook("zenstack:after_mutation", "delete", args.model, [data]);
+  return { data };
+}

package/dist/runtime/server/utils/operations/findMany.d.ts

@@ -0,0 +1,14 @@
+import type { $Zclient, $Zmodel, $Zinclude, $ZorderBy, $Zwhere, $Zitem } from '#build/types/nuxt-zenstack';
+type FindManyArgs<Zmodel extends $Zmodel> = {
+    client: $Zclient;
+    model: Zmodel;
+    include?: $Zinclude<Zmodel>;
+    orderBy?: $ZorderBy<Zmodel>;
+    where?: $Zwhere<Zmodel>;
+    skip?: number;
+    take?: number;
+};
+export declare function findMany<Zmodel extends $Zmodel>(args: FindManyArgs<Zmodel>): Promise<{
+    data: $Zitem<Zmodel, $Zinclude<Zmodel>>[];
+}>;
+export {};

package/dist/runtime/server/utils/operations/findMany.js

@@ -0,0 +1,14 @@
+import { getModelOperations, createError } from "./common.js";
+export async function findMany(args) {
+  const operations = getModelOperations(args.client, args.model);
+  const data = await operations.findMany({
+    orderBy: args.orderBy,
+    include: args.include,
+    skip: args.skip,
+    take: args.take,
+    where: args.where
+  }).catch((err) => {
+    throw createError(err);
+  });
+  return { data };
+}