@bg-dev/nuxt-zenstack 0.0.5 → 0.0.6

package/dist/module.d.mts

@@ -1,11 +1,7 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { FetchPolicy } from '../dist/runtime/composables/common.js';
+import { PublicModuleOptions, PrivateModuleOptions } from '../dist/runtime/types/index.js';
 
-interface ModuleOptions {
-    apiPath: string;
-    fetchPolicy: FetchPolicy;
-    realtime: boolean;
-    baseUrl: string;
+interface ModuleOptions extends PublicModuleOptions, PrivateModuleOptions {
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "configKey": "zenstack",
   "builder": {
     "@nuxt/module-builder": "1.0.2",

package/dist/module.mjs

@@ -3,7 +3,7 @@ import { joinURL } from 'ufo';
 import { defu } from 'defu';
 
 const name = "@bg-dev/nuxt-zenstack";
-const version = "0.0.5";
+const version = "0.0.6";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -16,7 +16,8 @@ const module$1 = defineNuxtModule({
     apiPath: "/api/_zenstack",
     fetchPolicy: "cache-first",
     realtime: false,
-    baseUrl: "http://localhost:3000"
+    baseUrl: "http://localhost:3000",
+    expose: {}
   },
   setup(_options, _nuxt) {
     _nuxt.options.runtimeConfig.public = defu(_nuxt.options.runtimeConfig.public, {
@@ -27,6 +28,10 @@ const module$1 = defineNuxtModule({
         baseUrl: _options.baseUrl
       }
     });
+    _nuxt.options.runtimeConfig.zenstack = {
+      expose: _options.expose,
+      ..._nuxt.options.runtimeConfig.zenstack ?? {}
+    };
     const resolver = createResolver(import.meta.url);
     addTemplate({
       write: true,
@@ -43,61 +48,7 @@ export { schema as zenstackSchema } from '~~/zenstack/schema'
     });
     addTypeTemplate({
       filename: "types/nuxt-zenstack.d.ts",
-      getContents: () => `
-import type { ClientContract, ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs } from '@zenstackhq/orm'
-import type { SchemaType } from '~~/zenstack/schema'
-import type { ModelDef } from '@zenstackhq/orm/schema'
-import type { H3Error } from 'h3'
-import { ORMError, RejectedByPolicyReason, ORMErrorReason } from '@zenstackhq/orm'
-
-type ItemGetPayload<Zmodel extends $Zmodel, Args extends SelectIncludeOmit<SchemaType, Zmodel, true>, Options extends QueryOptions<SchemaType> = QueryOptions<SchemaType>> = SimplifiedPlainResult<SchemaType, Zmodel, Args, Options>
-
-export type $Zschema = SchemaType
-export type $Zclient = ClientContract<SchemaType>
-export type $Zmodel = keyof SchemaType['models']
-export type $Zdef = ModelDef
-export type $Zoperations<Zmodel extends $Zmodel> = ModelOperations<SchemaType, Zmodel>
-export type $Zid<Zmodel extends $Zmodel> = ModelResult<SchemaType, Zmodel> extends { id: infer Id } ? Id : never
-export type $Zinclude<Zmodel extends $Zmodel> = IncludeInput<SchemaType, Zmodel> | undefined
-export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude = undefined> = ItemGetPayload<Zmodel, { include: Zinclude }>
-export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel> | undefined
-export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy'] | undefined
-
-type NonRelationalFields<Zmodel extends $Zmodel> = keyof $Zitem<Zmodel>
-type CreateData<Zmodel extends $Zmodel> = CreateArgs<SchemaType, Zmodel>['data']
-type UpdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel>['data']
-
-export type $ZcreateData<Zmodel extends $Zmodel> = Pick<CreateData<Zmodel>, NonRelationalFields<Zmodel>>
-export type $ZupdateData<Zmodel extends $Zmodel> = Pick<UpdateData<Zmodel>, NonRelationalFields<Zmodel>>
-export type $ZormError = ORMError
-export type $Zerror = H3Error<{
-  ormErrorReason: ORMErrorReason
-  dbErrorCode?: unknown
-  dbErrorMessage?: string
-  model?: string
-  rejectedByPolicyReason?: RejectedByPolicyReason
-}>
-
-declare module 'h3' {
-  interface H3EventContext {
-    zenstack: {
-      client: ClientContract<SchemaType>
-    }
-  }
-}
-
-type RealtimeData = {
-  action: 'create' | 'update' | 'delete'
-  model: $Zmodel
-  ids: Array<number | string>
-}
-
-declare module 'nitropack' {
-  interface NitroRuntimeHooks {
-    'zenstack:after_mutation': (action: 'create' | 'update' | 'delete', model: $Zmodel, items: Record<string, unknown>[]) => Promise<void> | void
-  }
-}
-`
+      src: resolver.resolve("./runtime/types/template.d.ts")
     });
     addServerHandler({
       route: joinURL(_options.apiPath, "models/:model"),

package/dist/runtime/composables/common.d.ts

@@ -1,7 +1,5 @@
-import type { ModuleOptions } from '../../module.js';
-export type Status = 'idle' | 'pending' | 'success' | 'error';
-export type FetchPolicy = 'cache-first' | 'fetch-only' | 'cache-only' | 'cache-and-fetch';
-export declare function getConfig(): ModuleOptions;
+import type { PublicModuleOptions } from '../types/index.js';
+export declare function getConfig(): PublicModuleOptions;
 /**
  * @param instance a custom fetch method created by `$fetch.create`
  */

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

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $ZcreateData, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status } from '../common.js';
+import type { Status } from '../../types/index.js';
 import { type Ref } from '#imports';
 export declare function useZenstackCreate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;

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

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $Zid, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status } from '../common.js';
+import type { Status } from '../../types/index.js';
 import { type Ref } from '#imports';
 export declare function useZenstackDelete<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;

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

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $Zid, $Zinclude, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status, FetchPolicy } from '../common.js';
+import type { Status, FetchPolicy } from '../../types/index.js';
 import type { Ref } from '#imports';
 type Options<Zinclude> = {
     /**

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

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $Zinclude, $Zwhere, $ZorderBy, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status, FetchPolicy } from '../common.js';
+import type { Status, FetchPolicy } from '../../types/index.js';
 import type { MaybeRefOrGetter, Ref } from '#imports';
 type Options<Zinclude, Zwhere, ZorderBy> = {
     /**

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

@@ -81,7 +81,7 @@ export async function useZenstackReadMany(model, opts = {}) {
     } catch (err) {
       error.value = err.data;
       status.value = "error";
-      canFetchMore.value = true;
+      canFetchMore.value = false;
     }
   }
   return { data, error, status, canFetchMore, refetch };

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

@@ -1,5 +1,5 @@
 import type { $Zmodel, $Zitem, $ZupdateData, $Zid, $Zerror } from '#build/types/nuxt-zenstack';
-import type { Status } from '../common.js';
+import type { Status } from '../../types/index.js';
 import type { Ref } from '#imports';
 export declare function useZenstackUpdate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;

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

@@ -1,9 +1,14 @@
-import { defineEventHandler } from "h3";
+import { defineEventHandler, createError } from "h3";
 import { parseModel, parseId, parseClient } from "../../../utils/parsers.js";
 import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
-  const client = parseClient(event);
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "delete")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(event);
   const id = parseId(event, model);
   const zenstack = useZenstack();
   return zenstack.delete({ client, model, id });

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

@@ -1,9 +1,14 @@
 import { parseModel, parseId, parseReadArgs, parseClient } from "../../../utils/parsers.js";
-import { defineEventHandler } from "h3";
+import { defineEventHandler, createError } from "h3";
 import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
-  const client = parseClient(event);
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "read")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(event);
   const id = parseId(event, model);
   const readArgs = parseReadArgs(event, model);
   const zenstack = useZenstack();

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

@@ -1,9 +1,14 @@
 import { parseModel, parseId, parseUpdateArgs, parseClient } from "../../../utils/parsers.js";
-import { defineEventHandler } from "h3";
+import { defineEventHandler, createError } from "h3";
 import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
-  const client = parseClient(event);
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "update")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(event);
   const id = parseId(event, model);
   const updateArgs = await parseUpdateArgs(event, model);
   const zenstack = useZenstack();

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

@@ -1,9 +1,14 @@
 import { parseClient, parseModel, parseReadArgs } from "../../../utils/parsers.js";
-import { defineEventHandler } from "h3";
+import { defineEventHandler, createError } from "h3";
 import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
-  const client = parseClient(event);
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "read")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(event);
   const readArgs = parseReadArgs(event, model);
   const zenstack = useZenstack();
   return zenstack.findMany({

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

@@ -1,9 +1,14 @@
 import { parseModel, parseCreateArgs, parseClient } from "../../../utils/parsers.js";
-import { defineEventHandler } from "h3";
+import { defineEventHandler, createError } from "h3";
 import { useZenstack } from "../../../utils/index.js";
+import { getConfig } from "../../../utils/helpers.js";
 export default defineEventHandler(async (event) => {
-  const client = parseClient(event);
   const model = parseModel(event);
+  const config = getConfig();
+  if (!config.expose[model]?.find((permission) => permission === "create")) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  const client = parseClient(event);
   const createArgs = await parseCreateArgs(event, model);
   const zenstack = useZenstack();
   return zenstack.create({ client, model, data: createArgs.data });

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

@@ -1,9 +1,14 @@
 import { defineEventHandler, createEventStream } from "h3";
 import { useNitroApp } from "nitropack/runtime";
+import { getConfig } from "../utils/helpers.js";
 export default defineEventHandler(async (event) => {
   const eventStream = createEventStream(event);
   const nitroApp = useNitroApp();
+  const config = getConfig();
   nitroApp.hooks.hook("zenstack:after_mutation", (action, model, items) => {
+    if (!config.expose[model]?.find((permission) => permission === "read")) {
+      return;
+    }
     const message = {
       model,
       action,

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

@@ -1,7 +1,9 @@
 import type { $Zmodel, $Zdef, $ZcreateData, $ZupdateData } from '#build/types/nuxt-zenstack';
+import type { PrivateModuleOptions } from '../../types/index.js';
 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>;
+export declare function getConfig(): PrivateModuleOptions;

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

@@ -1,4 +1,5 @@
 import { zenstackSchema } from "nuxt-zenstack-server.mjs";
+import { useRuntimeConfig } from "#imports";
 export function getModelDef(model) {
   return zenstackSchema.models[model];
 }
@@ -32,3 +33,7 @@ export function sanitizeUpdateData(model, data) {
   });
   return data;
 }
+export function getConfig() {
+  const config = useRuntimeConfig();
+  return config.zenstack;
+}

package/dist/runtime/types/index.d.ts

@@ -0,0 +1,12 @@
+import type { $Zmodel } from '#build/types/nuxt-zenstack';
+export type Status = 'idle' | 'pending' | 'success' | 'error';
+export type FetchPolicy = 'cache-first' | 'fetch-only' | 'cache-only' | 'cache-and-fetch';
+export interface PublicModuleOptions {
+    apiPath: string;
+    fetchPolicy: FetchPolicy;
+    realtime: boolean;
+    baseUrl: string;
+}
+export interface PrivateModuleOptions {
+    expose: Partial<Record<$Zmodel, Array<'create' | 'read' | 'update' | 'delete'>>>;
+}

package/dist/runtime/types/template.d.ts

@@ -0,0 +1,52 @@
+import type { ClientContract, ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs, ORMError, RejectedByPolicyReason, ORMErrorReason } from '@zenstackhq/orm'
+import type { SchemaType } from '~~/zenstack/schema'
+import type { ModelDef } from '@zenstackhq/orm/schema'
+import type { H3Error } from 'h3'
+
+type ItemGetPayload<Zmodel extends $Zmodel, Args extends SelectIncludeOmit<SchemaType, Zmodel, true>, Options extends QueryOptions<SchemaType> = QueryOptions<SchemaType>> = SimplifiedPlainResult<SchemaType, Zmodel, Args, Options>
+
+export type $Zschema = SchemaType
+export type $Zclient = ClientContract<SchemaType>
+export type $Zmodel = keyof SchemaType['models']
+export type $Zdef = ModelDef
+export type $Zoperations<Zmodel extends $Zmodel> = ModelOperations<SchemaType, Zmodel>
+export type $Zid<Zmodel extends $Zmodel> = ModelResult<SchemaType, Zmodel> extends { id: infer Id } ? Id : never
+export type $Zinclude<Zmodel extends $Zmodel> = IncludeInput<SchemaType, Zmodel> | undefined
+export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude = undefined> = ItemGetPayload<Zmodel, { include: Zinclude }>
+export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel> | undefined
+export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy'] | undefined
+
+type NonRelationalFields<Zmodel extends $Zmodel> = keyof $Zitem<Zmodel>
+type CreateData<Zmodel extends $Zmodel> = CreateArgs<SchemaType, Zmodel>['data']
+type UpdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel>['data']
+
+export type $ZcreateData<Zmodel extends $Zmodel> = Pick<CreateData<Zmodel>, NonRelationalFields<Zmodel>>
+export type $ZupdateData<Zmodel extends $Zmodel> = Pick<UpdateData<Zmodel>, NonRelationalFields<Zmodel>>
+export type $ZormError = ORMError
+export type $Zerror = H3Error<{
+  ormErrorReason: ORMErrorReason
+  dbErrorCode?: unknown
+  dbErrorMessage?: string
+  model?: string
+  rejectedByPolicyReason?: RejectedByPolicyReason
+}>
+
+declare module 'h3' {
+  interface H3EventContext {
+    zenstack: {
+      client: ClientContract<SchemaType>
+    }
+  }
+}
+
+type RealtimeData = {
+  action: 'create' | 'update' | 'delete'
+  model: $Zmodel
+  ids: Array<number | string>
+}
+
+declare module 'nitropack' {
+  interface NitroRuntimeHooks {
+    'zenstack:after_mutation': (action: 'create' | 'update' | 'delete', model: $Zmodel, items: Record<string, unknown>[]) => Promise<void> | void
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bg-dev/nuxt-zenstack",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "ZenStack integration for Nuxt",
   "repository": {
     "url": "https://github.com/becem-gharbi/nuxt-zenstack"
@@ -42,7 +42,7 @@
     "dev:db:push": "cd playground && zen db push",
     "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
     "lint": "eslint .",
-    "test": "vitest run",
+    "test": "vitest run --no-file-parallelism",
     "test:watch": "vitest watch",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
     "test:db:push": "cd test/fixtures/basic && zen db push",
@@ -73,7 +73,7 @@
     "eslint": "^9.39.2",
     "libsql": "^0.5.22",
     "nuxt": "^4.2.2",
-    "playwright-core": "^1.57.0",
+    "playwright-core": "^1.58.0",
     "typescript": "~5.9.3",
     "vitest": "^4.0.17",
     "vue-tsc": "^3.2.2"