@bg-dev/nuxt-zenstack 0.0.1

package/README.md

@@ -0,0 +1,75 @@
+# Nuxt ZenStack
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+ZenStack integration for Nuxt for doing amazing things.
+
+- [✨  Release Notes](/CHANGELOG.md)
+<!-- - [🏀 Online playground](https://stackblitz.com/github/your-org/@bg-dev/nuxt-zenstack?file=playground%2Fapp.vue) -->
+<!-- - [📖 &nbsp;Documentation](https://example.com) -->
+
+## Features
+
+<!-- Highlight some of the features your module provide here -->
+- ⛰ &nbsp;Foo
+- 🚠 &nbsp;Bar
+- 🌲 &nbsp;Baz
+
+## Quick Setup
+
+Install the module to your Nuxt application with one command:
+
+```bash
+npx nuxt module add @bg-dev/nuxt-zenstack
+```
+
+That's it! You can now use Nuxt ZenStack in your Nuxt app ✨
+
+
+## Contribution
+
+<details>
+  <summary>Local development</summary>
+  
+  ```bash
+  # Install dependencies
+  npm install
+  
+  # Generate type stubs
+  npm run dev:prepare
+  
+  # Develop with the playground
+  npm run dev
+  
+  # Build the playground
+  npm run dev:build
+  
+  # Run ESLint
+  npm run lint
+  
+  # Run Vitest
+  npm run test
+  npm run test:watch
+  
+  # Release new version
+  npm run release
+  ```
+
+</details>
+
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/@bg-dev/nuxt-zenstack/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/@bg-dev/nuxt-zenstack
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/@bg-dev/nuxt-zenstack.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npm.chart.dev/@bg-dev/nuxt-zenstack
+
+[license-src]: https://img.shields.io/npm/l/@bg-dev/nuxt-zenstack.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/@bg-dev/nuxt-zenstack
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -0,0 +1,9 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+    apiPath: string;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@bg-dev/nuxt-zenstack",
+  "version": "0.0.1",
+  "configKey": "zenstack",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,85 @@
+import { defineNuxtModule, createResolver, addServerImports, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler } from '@nuxt/kit';
+import { joinURL } from 'ufo';
+import { defu } from 'defu';
+
+const name = "@bg-dev/nuxt-zenstack";
+const version = "0.0.1";
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name,
+    version,
+    configKey: "zenstack"
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {
+    apiPath: "/api/models"
+  },
+  setup(_options, _nuxt) {
+    _nuxt.options.runtimeConfig.public = defu(_nuxt.options.runtimeConfig.public, {
+      zenstack: {
+        apiPath: _options.apiPath
+      }
+    });
+    const resolver = createResolver(import.meta.url);
+    addServerImports({
+      from: resolver.resolve("./runtime/server/utils"),
+      name: "provideClient",
+      as: "provideZenStackClient"
+    });
+    addTemplate({
+      write: true,
+      filename: "nuxt-zenstack.mjs",
+      getContents: () => `
+export { schema as zenstackSchema } from '~~/zenstack/schema'
+`
+    });
+    addServerTemplate({
+      filename: "nuxt-zenstack-server.mjs",
+      getContents: () => `
+export { schema as zenstackSchema } from '~~/zenstack/schema'
+`
+    });
+    addTypeTemplate({
+      filename: "types/nuxt-zenstack.d.ts",
+      getContents: () => `
+import type { ModelOperations, ModelResult, IncludeInput, WhereInput, FindManyArgs, SimplifiedPlainResult, SelectIncludeOmit, QueryOptions, CreateArgs, UpdateArgs } from '@zenstackhq/orm'
+import type { SchemaType } from '~~/zenstack/schema'
+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 $Zmodel = keyof SchemaType['models']
+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>
+export type $Zitem<Zmodel extends $Zmodel, Zinclude extends $Zinclude<Zmodel> = never> = ItemGetPayload<Zmodel, { include: Zinclude }>
+export type $Zwhere<Zmodel extends $Zmodel> = WhereInput<SchemaType, Zmodel>
+export type $ZorderBy<Zmodel extends $Zmodel> = FindManyArgs<SchemaType, Zmodel>['orderBy']
+export type $ZcreateData<Zmodel extends $Zmodel> = CreateArgs<SchemaType, Zmodel>['data']
+export type $ZupdateData<Zmodel extends $Zmodel> = UpdateArgs<SchemaType, Zmodel>['data']
+export type $Zerror = {message: string, reason: string, rejectedByValidation: boolean, model: string}
+`
+    });
+    addServerHandler({
+      route: joinURL(_options.apiPath, "/:model"),
+      handler: resolver.resolve("./runtime/server/api/[model]/index.get")
+    });
+    addServerHandler({
+      route: joinURL(_options.apiPath, "/:model"),
+      handler: resolver.resolve("./runtime/server/api/[model]/index.post")
+    });
+    addServerHandler({
+      route: joinURL(_options.apiPath, "/:model/:id"),
+      handler: resolver.resolve("./runtime/server/api/[model]/[id].patch")
+    });
+    addServerHandler({
+      route: joinURL(_options.apiPath, "/:model/:id"),
+      handler: resolver.resolve("./runtime/server/api/[model]/[id].delete")
+    });
+    addServerHandler({
+      route: joinURL(_options.apiPath, "/:model/:id"),
+      handler: resolver.resolve("./runtime/server/api/[model]/[id].get")
+    });
+  }
+});
+
+export { module$1 as default };

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

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

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

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

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

@@ -0,0 +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/[model]/[id].get.js

@@ -0,0 +1,16 @@
+import { parseModel, parseId, parseReadArgs } from "../../utils/parsers.js";
+import { defineEventHandler } from "h3";
+import { getModelOperations } from "../../utils/index.js";
+export default defineEventHandler(async (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 };
+});

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

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

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

@@ -0,0 +1,16 @@
+import { parseModel, parseId, parseUpdateData } from "../../utils/parsers.js";
+import { defineEventHandler } from "h3";
+import { getModelOperations } from "../../utils/index.js";
+export default defineEventHandler(async (event) => {
+  const model = parseModel(event);
+  const id = parseId(event, model);
+  const updateData = await parseUpdateData(event, model);
+  const operations = getModelOperations(model);
+  const data = await operations.update({
+    data: updateData.data,
+    where: {
+      id
+    }
+  });
+  return { data };
+});

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

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

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

@@ -0,0 +1,16 @@
+import { parseModel, parseReadArgs } from "../../utils/parsers.js";
+import { defineEventHandler } from "h3";
+import { getModelOperations } from "../../utils/index.js";
+export default defineEventHandler(async (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,
+    skip: readArgs.skip,
+    take: readArgs.take,
+    where: readArgs.where
+  });
+  return { data };
+});

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

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

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

@@ -0,0 +1,12 @@
+import { parseModel, parseCreateData } from "../../utils/parsers.js";
+import { defineEventHandler } from "h3";
+import { getModelOperations } from "../../utils/index.js";
+export default defineEventHandler(async (event) => {
+  const model = parseModel(event);
+  const createData = await parseCreateData(event, model);
+  const operations = getModelOperations(model);
+  const data = await operations.create({
+    data: createData.data
+  });
+  return { data };
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

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

@@ -0,0 +1,11 @@
+import type { ClientContract } from '@zenstackhq/orm';
+import type { $Zschema, $Zmodel, $Zoperations } 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 getModelDef(model: $Zmodel): any;
+export declare function isIdString(model: $Zmodel): boolean;
+export declare function getModels(): $Zmodel[];
+export declare function isValidModel(model: $Zmodel): boolean;
+export declare function getModelOperations<Zmodel extends $Zmodel>(model: Zmodel): $Zoperations<Zmodel>;
+export {};

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

@@ -0,0 +1,27 @@
+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 getModelDef(model) {
+  return zenstackSchema.models[model];
+}
+export function isIdString(model) {
+  return getModelDef(model).uniqueFields.id.type === "String";
+}
+export function getModels() {
+  return Object.keys(zenstackSchema.models);
+}
+export function isValidModel(model) {
+  return getModels().includes(model);
+}
+export function getModelOperations(model) {
+  const db = getClient();
+  return db[model.toString().toLocaleLowerCase()];
+}

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

@@ -0,0 +1,19 @@
+import type { H3Event } from 'h3';
+import type { $Zmodel, $Zinclude, $Zwhere, $ZorderBy, $ZcreateData, $ZupdateData } from '#build/types/nuxt-zenstack';
+type ReadArgs<Zmodel extends $Zmodel> = {
+    include?: $Zinclude<Zmodel>;
+    where?: $Zwhere<Zmodel>;
+    orderBy?: $ZorderBy<Zmodel>;
+    skip?: number;
+    take?: number;
+};
+export declare function parseModel(event: H3Event): string | number | symbol;
+export declare function parseId(event: H3Event, model: $Zmodel): string | number;
+export declare function parseReadArgs<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): ReadArgs<Zmodel>;
+export declare function parseCreateData<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): Promise<{
+    data: $ZcreateData<Zmodel>;
+}>;
+export declare function parseUpdateData<Zmodel extends $Zmodel>(event: H3Event, _model: Zmodel): Promise<{
+    data: $ZupdateData<Zmodel>;
+}>;
+export {};

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

@@ -0,0 +1,28 @@
+import { getRouterParam, createError, getQuery, readBody } from "h3";
+import { isValidModel, isIdString } from "./index.js";
+import { parse } from "superjson";
+export function parseModel(event) {
+  const model = getRouterParam(event, "model");
+  if (isValidModel(model) === false) {
+    throw createError({ statusCode: 400, statusMessage: "Invalid model" });
+  }
+  return model;
+}
+export function parseId(event, model) {
+  const id = getRouterParam(event, "id");
+  const parsedId = isIdString(model) ? id : Number(id);
+  if (typeof parsedId === "number" && Number.isNaN(parsedId)) {
+    throw createError({ statusCode: 400, statusMessage: "Invalid id" });
+  }
+  return id;
+}
+export function parseReadArgs(event, _model) {
+  const query = getQuery(event);
+  return query?.q ? parse(query.q) : {};
+}
+export async function parseCreateData(event, _model) {
+  return readBody(event);
+}
+export async function parseUpdateData(event, _model) {
+  return readBody(event);
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@bg-dev/nuxt-zenstack",
+  "version": "0.0.1",
+  "description": "ZenStack integration for Nuxt",
+  "repository": {
+    "url": "https://github.com/becem-gharbi/nuxt-zenstack"
+  },
+  "author": {
+    "name": "Becem Gharbi"
+  },
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "nuxt",
+    "ZenStack",
+    "module"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "dev:db:generate": "cd playground && zen generate",
+    "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:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
+    "test:db:push": "cd test/fixtures/basic && zen db push",
+    "test:db:generate": "cd test/fixtures/basic && zen generate",
+    "typecheck": "nuxt typecheck"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.2.2",
+    "@zenstackhq/orm": "3.2.1",
+    "defu": "^6.1.4",
+    "superjson": "^2.2.6",
+    "ufo": "^1.6.3"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/eslint": "1.12.1",
+    "@nuxt/eslint-config": "^1.12.1",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.2.2",
+    "@nuxt/test-utils": "^3.23.0",
+    "@types/node": "latest",
+    "@zenstackhq/cli": "3.2.1",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.2",
+    "libsql": "^0.5.22",
+    "nuxt": "^4.2.2",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.17",
+    "vue-tsc": "^3.2.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  }
+}