nuxt-feathers-zod 0.1.0

package/dist/runtime/services.js

@@ -0,0 +1,14 @@
+import { addImports, addServerImports } from "@nuxt/kit";
+import { scanDirExports } from "unimport";
+export async function getServicesImports(servicesDirs) {
+  const exports = await scanDirExports(servicesDirs, {
+    filePatterns: ["**/*.schema.ts"]
+  });
+  const typeExports = exports.filter(({ type }) => type);
+  console.log("Services typeExports", typeExports.map(({ as }) => as));
+  return typeExports;
+}
+export async function addServicesImports(imports) {
+  addImports(imports);
+  addServerImports(imports);
+}

package/dist/runtime/stores/auth.d.ts

@@ -0,0 +1,28 @@
+export declare const useAuthStore: import("pinia").StoreDefinition<"auth", Pick<{
+    userId: import("vue").ComputedRef<any>;
+    authenticate: (payload: any) => Promise<void>;
+    reAuthenticate: () => Promise<void>;
+    logout: () => void;
+    user: import("vue").Ref<any, any>;
+    authenticated: import("vue").Ref<boolean, boolean>;
+    accessToken: import("vue").Ref<string | null, string | null>;
+    error: import("vue").Ref<any, any>;
+}, "user" | "error" | "authenticated" | "accessToken">, Pick<{
+    userId: import("vue").ComputedRef<any>;
+    authenticate: (payload: any) => Promise<void>;
+    reAuthenticate: () => Promise<void>;
+    logout: () => void;
+    user: import("vue").Ref<any, any>;
+    authenticated: import("vue").Ref<boolean, boolean>;
+    accessToken: import("vue").Ref<string | null, string | null>;
+    error: import("vue").Ref<any, any>;
+}, "userId">, Pick<{
+    userId: import("vue").ComputedRef<any>;
+    authenticate: (payload: any) => Promise<void>;
+    reAuthenticate: () => Promise<void>;
+    logout: () => void;
+    user: import("vue").Ref<any, any>;
+    authenticated: import("vue").Ref<boolean, boolean>;
+    accessToken: import("vue").Ref<string | null, string | null>;
+    error: import("vue").Ref<any, any>;
+}, "authenticate" | "reAuthenticate" | "logout">>;

package/dist/runtime/stores/auth.js

@@ -0,0 +1,47 @@
+import { acceptHMRUpdate, defineStore } from "pinia";
+import { computed, reactive, toRefs } from "vue";
+export const useAuthStore = defineStore("auth", () => {
+  const state = reactive({
+    user: null,
+    authenticated: false,
+    accessToken: null,
+    error: null
+  });
+  const userId = computed(
+    () => state.user?.id ?? state.user?._id ?? null
+  );
+  async function authenticate(payload) {
+    const api = useNuxtApp().$api;
+    const result = await api.authenticate(payload);
+    state.accessToken = result.accessToken;
+    state.user = result.user;
+    state.authenticated = true;
+  }
+  async function reAuthenticate() {
+    try {
+      const api = useNuxtApp().$api;
+      const result = await api.reAuthenticate();
+      state.accessToken = result.accessToken;
+      state.user = result.user;
+      state.authenticated = true;
+    } catch {
+      logout();
+    }
+  }
+  function logout() {
+    const api = useNuxtApp().$api;
+    api.logout?.();
+    state.user = null;
+    state.accessToken = null;
+    state.authenticated = false;
+  }
+  return {
+    ...toRefs(state),
+    userId,
+    authenticate,
+    reAuthenticate,
+    logout
+  };
+});
+if (import.meta.hot)
+  import.meta.hot.accept(acceptHMRUpdate(useAuthStore, import.meta.hot));

package/dist/runtime/templates/client/authentication.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedOptions } from '../../options/index.js';
+export declare function getClientAuthContents(options: ResolvedOptions): () => string;

package/dist/runtime/templates/client/authentication.js

@@ -0,0 +1,28 @@
+import { put } from "../utils.js";
+export function getClientAuthContents(options) {
+  return () => {
+    const jwt = options.auth?.authStrategies?.includes("jwt");
+    return `// ! Generated by nuxt-feathers-zod - do not change manually
+import type { ClientApplication } from './client.js'
+import {${put(jwt, `useCookie,`)} useRuntimeConfig } from '#app'
+import authenticationClient, { type AuthenticationClientOptions } from '@feathersjs/authentication-client'
+import { klona } from 'klona'
+
+export function authentication(client: ClientApplication) {
+  const clientOptions = useRuntimeConfig().public._feathers.auth?.client
+  const authClientOptions = klona(clientOptions) as AuthenticationClientOptions
+ 
+${put(jwt, `  // Store JWT in a cookie for SSR.
+  const jwt = useCookie<string | null>(authClientOptions.storageKey)
+  const storage = {
+    getItem: () => jwt.value,
+    setItem: (key: string, val: string) => (jwt.value = val),
+    removeItem: () => (jwt.value = null),
+  }
+  authClientOptions.storage = storage
+`)}
+  client.configure(authenticationClient(authClientOptions))
+}
+`;
+  };
+}

package/dist/runtime/templates/client/client.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedOptions } from '../../options/index.js';
+export declare function getClientContents(options: ResolvedOptions): () => string;

package/dist/runtime/templates/client/client.js

@@ -0,0 +1,50 @@
+import { put } from "../utils.js";
+export function getClientContents(options) {
+  return () => {
+    const pinia = !!options?.client?.pinia;
+    const apiType = pinia ? "FeathersPiniaClient<ClientApplication>" : "ClientApplication";
+    let entity, entityImport;
+    const auth = options?.auth;
+    if (auth) {
+      entity = auth.entity;
+      entityImport = auth.entityImport;
+    }
+    return `// ! Generated by nuxt-feathers-zod - do not change manually
+  ${put(auth, `import type { User } from '${entityImport?.from}'`)}
+  import type { Application, TransportConnection } from '@feathersjs/feathers'
+  ${put(pinia, `import type { FeathersPiniaClient } from 'feathers-pinia'`)}
+  
+  export interface Configuration {
+    connection: TransportConnection<ServiceTypes>
+  }
+  
+  export interface ServiceTypes {}
+  
+  export type ClientApplication = Application<ServiceTypes, Configuration>
+  
+  export type FeathersClientPlugin = Parameters<ClientApplication['configure']>['0']
+  
+  export function defineFeathersClientPlugin(def: FeathersClientPlugin): FeathersClientPlugin {
+    return def;
+  }
+  ${put(auth, `  
+  declare module '@feathersjs/feathers' {
+    interface Params {
+      ${entity}?: ${entityImport?.as}
+    }
+  }`)}
+  
+  declare module '#app' {
+    interface NuxtApp {
+      $api: ${apiType}
+    }
+  }
+  
+  declare module 'vue' {
+    interface ComponentCustomProperties {
+      $api: ${apiType}
+    }
+  }
+  `;
+  };
+}

package/dist/runtime/templates/client/connection.d.ts

@@ -0,0 +1,3 @@
+import type { Resolver } from '@nuxt/kit';
+import type { ResolvedOptions } from '../../options/index.js';
+export declare function getClientConnectionContents(options: ResolvedOptions, resolver: Resolver): () => string;

package/dist/runtime/templates/client/connection.js

@@ -0,0 +1,39 @@
+import { put, puts } from "../utils.js";
+export function getClientConnectionContents(options, resolver) {
+  return () => {
+    const pinia = !!options.client?.pinia;
+    const transports = options?.transports;
+    const rest = !!transports?.rest;
+    const sio = !!transports?.websocket;
+    const restPath = transports?.rest?.path;
+    const sioPath = transports?.websocket?.path;
+    const restConnection = `rest(new URL('${restPath}', origin).href).fetch($fetch, OFetch)`;
+    const sioConnection = `socketioClient(io(origin, { path: '${sioPath}', transports: ['websocket'] }))`;
+    return `// ! Generated by nuxt-feathers-zod - do not change manually
+// You can set it in nuxt.config.js with the feathers.transports option
+import type { ClientApplication } from './client.js'
+${puts([
+      [rest, `import rest from '@feathersjs/rest-client'
+import { $fetch } from 'ofetch'`],
+      [sio, `import socketioClient from '@feathersjs/socketio-client'
+import { io } from 'socket.io-client'`],
+      [rest, `import { OFetch } from '${put(pinia, "feathers-pinia", resolver.resolve("./runtime/adapters/ofetch"))}'`]
+    ])}
+
+export function connection(origin?: string) {
+  return function (client: ClientApplication) {
+    const connection = ${put(rest && sio, `import.meta.server
+      ? ${restConnection}
+      : ${sioConnection}`, puts([
+      [rest || !sio, restConnection],
+      [sio, sioConnection]
+    ]))}
+
+    client.configure(connection)
+
+    client.set('connection', connection)
+  }
+}
+`;
+  };
+}

package/dist/runtime/templates/client/index.d.ts

@@ -0,0 +1,4 @@
+import type { Resolver } from '@nuxt/kit';
+import type { ResolvedOptions } from '../../options/index.js';
+import type { Templates } from '../types.js';
+export declare function getClientTemplates(options: ResolvedOptions, resolver: Resolver): Templates;

package/dist/runtime/templates/client/index.js

@@ -0,0 +1,33 @@
+import { getClientAuthContents } from "./authentication.js";
+import { getClientContents } from "./client.js";
+import { getClientConnectionContents } from "./connection.js";
+import { getClientPluginContents } from "./plugin.js";
+export function getClientTemplates(options, resolver) {
+  const clientTemplates = [
+    {
+      filename: "feathers/client/client.ts",
+      getContents: getClientContents(options),
+      write: true
+    },
+    {
+      filename: "feathers/client/connection.ts",
+      getContents: getClientConnectionContents(options, resolver),
+      write: true
+    },
+    {
+      filename: "feathers/client/plugin.ts",
+      getContents: getClientPluginContents(options),
+      write: true
+    }
+  ];
+  if (options.auth) {
+    clientTemplates.push(
+      {
+        filename: "feathers/client/authentication.ts",
+        getContents: getClientAuthContents(options),
+        write: true
+      }
+    );
+  }
+  return clientTemplates;
+}

package/dist/runtime/templates/client/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedOptions } from '../../options/index.js';
+export declare function getClientPluginContents(options: ResolvedOptions): () => Promise<string>;

package/dist/runtime/templates/client/plugin.js

@@ -0,0 +1,81 @@
+import { scanDirExports } from "unimport";
+import { setImportsMeta } from "../../options/utils.js";
+import { put } from "../utils.js";
+async function getServices(servicesDirs) {
+  const services = await scanDirExports(servicesDirs, {
+    filePatterns: ["**/*.shared.ts"],
+    fileFilter: (file) => /\.shared\.ts$/.test(file),
+    types: false
+  });
+  return services.filter(({ name }) => /Client|default$/.test(name));
+}
+export function getClientPluginContents(options) {
+  return async () => {
+    const services = setImportsMeta(await getServices(options.servicesDirs));
+    const plugins = options.client.plugins;
+    const modules = [...services, ...plugins];
+    const auth = (options?.auth?.authStrategies || []).length > 0;
+    const pinia = !!options?.client?.pinia;
+    return `// ! Generated by nuxt-feathers-zod - do not change manually
+// For more information about this file see https://dove.feathersjs.com/guides/cli/client.html
+
+import { useRequestURL } from "#imports"
+import type { ClientApplication } from './client.js'
+import { feathers } from '@feathersjs/feathers'
+import { defineNuxtPlugin${put(pinia, `, useRuntimeConfig`)} } from '#app'
+${put(pinia, `import { createPiniaClient, type CreatePiniaClientConfig } from 'feathers-pinia'`)}
+
+import { connection } from './connection.js'
+${put(auth, `import { authentication } from './authentication.js'`)}
+
+${modules.map((module) => module.meta.import).join("\n")}
+
+/**
+ * Returns a typed client for the feathers-api app.
+ *
+ * @param connection The REST or Socket.io Feathers client connection
+ * @param authenticationOptions Additional settings for the authentication client
+ * @see https://dove.feathersjs.com/api/client.html
+ * @returns The Feathers client application
+ */
+function createFeathersClient(): ClientApplication {
+  const feathersClient: ClientApplication = feathers()
+
+  // Init connection
+  const { origin } = useRequestURL()
+  feathersClient.configure(connection(origin))
+
+  // Init authentication
+  ${put(auth, `feathersClient.configure(authentication)`)}
+
+  // Init services
+  ${services.map((service) => `feathersClient.configure(${service.meta.importId})`).join("\n  ")}
+
+  // Init plugins
+  ${plugins.map((plugin) => `feathersClient.configure(${plugin.meta.importId})`).join("\n  ")}
+
+  return feathersClient
+}
+
+/**
+ * Creates a Feathers Rest client for the SSR server and a Socket.io client for the browser.
+ * Also provides a cookie-storage adapter for JWT SSR using Nuxt APIs.
+ */
+export default defineNuxtPlugin(async (nuxt) => {
+  // create the feathers client
+  const feathersClient: ClientApplication = createFeathersClient()
+  ${put(pinia, `
+  const piniaOptions = useRuntimeConfig().public._feathers.pinia
+  `)}
+  // wrap the feathers client
+  const api = ${put(pinia, `createPiniaClient(feathersClient, {
+    ssr: !!import.meta.server,
+    ...piniaOptions as CreatePiniaClientConfig,
+    pinia: nuxt.$pinia,
+  })`, `feathersClient`)}
+
+  return { provide: { api } }
+})
+`;
+  };
+}

package/dist/runtime/templates/server/authentication.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedOptions } from '../../options/index.js';
+export declare function getServerAuthContents(options: ResolvedOptions): () => string;

package/dist/runtime/templates/server/authentication.js

@@ -0,0 +1,32 @@
+import { put, puts } from "../utils.js";
+export function getServerAuthContents(options) {
+  return () => {
+    const authStrategies = options.auth.authStrategies;
+    const jwt = authStrategies.includes("jwt");
+    const local = authStrategies.includes("local");
+    return `// ! Generated by nuxt-feathers-zod - do not change manually
+import { useRuntimeConfig } from '#imports'
+import { defineFeathersServerPlugin } from './server.js'
+import { AuthenticationService ${put(jwt, `, JWTStrategy `)}} from '@feathersjs/authentication'
+${put(local, `import { LocalStrategy } from '@feathersjs/authentication-local'`)}
+
+export default defineFeathersServerPlugin((app) => {
+  const authOptions = useRuntimeConfig()._feathers.auth
+  const authentication = new AuthenticationService(app, 'authentication', authOptions)
+
+${puts([
+      [jwt, `  authentication.register('jwt', new JWTStrategy())`],
+      [local, `  authentication.register('local', new LocalStrategy())`]
+    ])}
+
+  app.use('authentication', authentication)
+})
+
+declare module './server' {
+  interface ServiceTypes {
+    authentication: AuthenticationService
+  }
+}
+`;
+  };
+}

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

@@ -0,0 +1,3 @@
+import type { ResolvedOptions } from '../../../runtime/options/index.js';
+import type { Templates } from '../types.js';
+export declare function getServerTemplates(options: ResolvedOptions): Templates;

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

@@ -0,0 +1,33 @@
+import { getServerAuthContents } from "./authentication.js";
+import { getServerMongodbContents } from "./mongodb.js";
+import { getServerPluginContents } from "./plugin.js";
+import { getServerContents } from "./server.js";
+export function getServerTemplates(options) {
+  const serverTemplates = [
+    {
+      filename: "feathers/server/server.ts",
+      getContents: getServerContents(options),
+      write: true
+    },
+    {
+      filename: "feathers/server/plugin.ts",
+      getContents: getServerPluginContents(options),
+      write: true
+    }
+  ];
+  if (options.database.mongo) {
+    serverTemplates.push({
+      filename: "feathers/server/mongodb.ts",
+      getContents: getServerMongodbContents(options),
+      write: true
+    });
+  }
+  if (options.auth) {
+    serverTemplates.push({
+      filename: "feathers/server/authentication.ts",
+      getContents: getServerAuthContents(options),
+      write: true
+    });
+  }
+  return serverTemplates;
+}

package/dist/runtime/templates/server/mongodb.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedOptions } from '../../options/index.js';
+export declare function getServerMongodbContents(options: ResolvedOptions): () => string;

package/dist/runtime/templates/server/mongodb.js

@@ -0,0 +1,26 @@
+import { klona } from "klona/json";
+export function getServerMongodbContents(options) {
+  return () => {
+    const mongoUrl = options?.database?.mongo?.url;
+    const mongoOptions = klona(options?.database?.mongo);
+    delete mongoOptions.url;
+    const mongoClientOptions = mongoOptions;
+    return `// ! Generated by nuxt-feathers-zod - do not change manually
+// For more information about this file see https://dove.feathersjs.com/guides/cli/databases.html
+
+import { MongoClient } from 'mongodb'
+import { defineFeathersServerPlugin } from './server.js'
+  
+const url = '${mongoUrl}'
+const options = ${JSON.stringify(mongoClientOptions, null, 2)}
+
+export default defineFeathersServerPlugin((app) => {
+  const database = new URL(url).pathname.substring(1)
+
+  const mongoClient = MongoClient.connect(url, options).then(client => client.db(database))
+
+  app.set('mongodbClient', mongoClient)
+})
+`;
+  };
+}

package/dist/runtime/templates/server/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedOptions } from '../../options/index.js';
+export declare function getServerPluginContents(options: ResolvedOptions): () => Promise<string>;

package/dist/runtime/templates/server/plugin.js

@@ -0,0 +1,110 @@
+import { scanDirExports } from "unimport";
+import { filterExports, setImportsMeta } from "../../options/utils.js";
+import { put, puts } from "../utils.js";
+async function getServices(servicesDirs) {
+  const services = await scanDirExports(servicesDirs, {
+    filePatterns: ["**/*.ts"],
+    types: false
+  });
+  return services.filter(({ from }) => !/\w+\.\w+\.ts$/.test(from)).filter(filterExports);
+}
+export function getServerPluginContents(options) {
+  return async () => {
+    const services = setImportsMeta(await getServices(options.servicesDirs));
+    const plugins = options.server.plugins;
+    const modules = [...services, ...plugins];
+    const transports = options?.transports;
+    const rest = !!transports?.rest;
+    const framework = transports?.rest?.framework;
+    const exp = framework === "express";
+    const koa = framework === "koa";
+    const sio = !!transports?.websocket;
+    const routers = [exp && "createExpressRouter", koa && "createKoaRouter", sio && "createSocketIoRouter"].filter(Boolean);
+    const mongo = !!options.database?.mongo;
+    const authStrategies = options?.auth?.authStrategies;
+    const auth = (authStrategies || []).length > 0;
+    const authService = options?.auth?.service;
+    const restPath = transports?.rest?.path;
+    const websocketPath = transports?.websocket?.path;
+    return `// ! Generated by nuxt-feathers-zod - do not change manually
+import type { NitroApp } from 'nitropack'
+import type { Application } from './server.js'
+${put(options.loadFeathersConfig, `import configuration from '@feathersjs/configuration'`)}
+import { feathers } from '@feathersjs/feathers'
+${puts([
+      [koa, `import { bodyParser, koa as feathersKoa, rest } from '@feathersjs/koa'`],
+      [exp, `import feathersExpress, { json, rest, urlencoded } from '@feathersjs/express'`],
+      [sio, `import socketio from '@feathersjs/socketio'`]
+    ])}
+${put(rest, `import { ${framework}ErrorHandler } from '@gabortorma/feathers-nitro-adapter/handlers'`)}
+${put(auth, `import authentication from './authentication.js'`)}
+import { ${routers.join(", ")} } from '@gabortorma/feathers-nitro-adapter/routers'
+import { defineNitroPlugin } from 'nitropack/dist/runtime/plugin'
+${put(mongo, `import mongodb from './mongodb.js'`)}
+${modules.map((module) => module.meta.import).join("\n")}
+
+export default defineNitroPlugin((nitroApp: NitroApp) => {
+  const app: Application = ${puts([
+      [koa, `feathersKoa(feathers())`],
+      [exp, `feathersExpress(feathers())`],
+      [!rest, `feathers()`]
+    ])}
+${put(options.loadFeathersConfig, `
+  app.configure(configuration())
+`)}
+  // Add nitroApp to feathers app
+  app.nitroApp = nitroApp;
+${put(rest, `${put(koa, `
+  // Set up Koa middleware
+  app.configure(koaErrorHandler)
+  app.use(bodyParser())`)}
+${put(exp, `  // Set up Express middleware
+  app.use(json())
+  app.use(urlencoded({ extended: true }))
+`)}
+  ${put(rest, `// Init rest server
+  app.set('framework', '${framework}')
+  app.configure(rest(${put(auth, `{
+    authentication: {
+      strategies: ['${authStrategies?.join(`', '`)}'],
+    },
+  }`)}))  
+`)}`)}
+  // Init socket.io server for real-time functionality
+  app.set('websocket', ${!!sio})${put(sio, `
+  app.configure(socketio({ 
+    path: '${websocketPath}',
+    transports: ['websocket']
+  }))`)}  
+
+  ${put(auth, `// Init auth
+  app.configure(authentication)
+`)}
+  ${put(mongo, `// Init mongodb
+  app.configure(mongodb)
+`)}
+  // Init services
+  ${services.map((service) => `app.configure(${service.meta.importId})`).join("\n  ")}
+
+  // Init plugins
+  ${plugins.map((plugin) => `app.configure(${plugin.meta.importId})`).join("\n  ")}
+${put(exp, `
+  // Set up Express middleware for 404s and the error handler
+  app.configure(expressErrorHandler)
+`)}
+  void app.setup().then(()=> { // TODO: make async in Nitro v3
+${puts([
+      [koa, `    // Init koa router
+    createKoaRouter(app, '${restPath}')`],
+      [exp, `    // Init express router
+    createExpressRouter(app, '${restPath}')`],
+      [sio, `    // Init socket.io router
+    createSocketIoRouter(app)`]
+    ])}        
+  }); 
+
+  nitroApp.hooks.hook("close", async () => app.teardown());  
+})
+`;
+  };
+}

package/dist/runtime/templates/server/server.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedOptions } from '../../options/index.js';
+export declare function getServerContents(options: ResolvedOptions): () => string;

package/dist/runtime/templates/server/server.js

@@ -0,0 +1,61 @@
+import { put, puts } from "../utils.js";
+export function getServerContents(options) {
+  return () => {
+    const transports = options?.transports;
+    const rest = !!transports?.rest;
+    const exp = (transports?.rest).framework === "express";
+    const koa = (transports?.rest).framework === "koa";
+    const mongo = !!options.database?.mongo;
+    let entity, entityImport;
+    const auth = options?.auth;
+    if (auth) {
+      entity = auth.entity;
+      entityImport = auth.entityImport;
+    }
+    return `// ! Generated by nuxt-feathers-zod - do not change manually
+import type { ${put(!rest, `Application as FeathersApplication, `)}HookContext as FeathersHookContext, NextFunction } from '@feathersjs/feathers'
+${put(mongo, `import type { Db } from 'mongodb'`)}
+${puts([
+      [koa, `import type { Application as FeathersApplication } from '@feathersjs/koa'`],
+      [exp, `import type { Application as FeathersApplication } from '@feathersjs/express'`]
+    ])}
+${put(auth, `import type { User } from '${entityImport?.from}'`)}
+// import type { ModuleOptions } from '???'
+import type { NitroApp } from 'nitropack'
+
+export type { NextFunction }
+
+export interface Configuration {
+  framework?: 'express' | 'koa'
+  websocket?: boolean${put(mongo, `
+  mongodbClient: Promise<Db>`)}  
+}
+
+// A mapping of service names to types. Will be extended in service files.
+export interface ServiceTypes {}
+
+export interface ApplicationAddons {
+  nitroApp?: NitroApp
+  // moduleOptions: ModuleOptions
+}
+
+// The application instance type that will be used everywhere else
+export type Application = FeathersApplication<ServiceTypes, Configuration> & ApplicationAddons
+
+// The context for hook functions - can be typed with a service class
+export type HookContext<S = any> = FeathersHookContext<Application, S>
+
+export type FeathersServerPlugin = Parameters<Application['configure']>['0']
+
+export function defineFeathersServerPlugin(def: FeathersServerPlugin): FeathersServerPlugin {
+  return def
+}
+${put(auth, `  
+declare module '@feathersjs/feathers' {
+  interface Params {
+    ${entity}?: ${entityImport?.as}
+  }
+}`)}
+`;
+  };
+}

package/dist/runtime/templates/server/validators.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedOptions } from '../../options/index.js';
+export declare function getServerValidatorContents(options: ResolvedOptions): () => string;