vitrify 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,10 +1,39 @@
 import vuePlugin from '@vitejs/plugin-vue';
 import { mergeConfig } from 'vite';
+import { build } from 'esbuild';
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
 import { readFileSync } from 'fs';
 import builtinModules from 'builtin-modules';
 import { resolve } from 'import-meta-resolve';
 import { getPkgJsonDir } from './app-urls.js';
-const serverModules = ['fastify', 'middie'];
+const serverModules = [
+    // 'fs',
+    // 'path',
+    // 'url',
+    // 'module',
+    // 'crypto',
+    // 'node:fs',
+    'util',
+    'node:url',
+    'node:util',
+    'node:fs',
+    'vitrify',
+    'vite',
+    'fastify',
+    'middie',
+    'knex',
+    'bcrypt',
+    'objection',
+    '@fastify/formbody',
+    '@fastify/static',
+    '@fastify/cors',
+    '@fastify/cookie',
+    'mercurius',
+    'jose',
+    'oidc-provider'
+];
 const configPluginMap = {
     quasar: () => import('./plugins/quasar.js').then((module) => module.QuasarPlugin)
 };
@@ -14,6 +43,54 @@ export const VIRTUAL_MODULES = [
     'virtual:global-css',
     'virtual:static-imports'
 ];
+async function bundleConfigFile(fileName, isESM = false) {
+    const result = await build({
+        absWorkingDir: process.cwd(),
+        entryPoints: [fileName],
+        outfile: 'out.js',
+        write: false,
+        platform: 'node',
+        bundle: true,
+        format: 'esm',
+        sourcemap: 'inline',
+        metafile: true,
+        plugins: [
+            {
+                name: 'externalize-deps',
+                setup(build) {
+                    build.onResolve({ filter: /.*/ }, (args) => {
+                        const id = args.path;
+                        if (id[0] !== '.' && !path.isAbsolute(id)) {
+                            return {
+                                external: true
+                            };
+                        }
+                    });
+                }
+            },
+            {
+                name: 'replace-import-meta',
+                setup(build) {
+                    build.onLoad({ filter: /\.[jt]s$/ }, async (args) => {
+                        const contents = await fs.promises.readFile(args.path, 'utf8');
+                        return {
+                            loader: args.path.endsWith('.ts') ? 'ts' : 'js',
+                            contents: contents
+                                .replace(/\bimport\.meta\.url\b/g, JSON.stringify(pathToFileURL(args.path).href))
+                                .replace(/\b__dirname\b/g, JSON.stringify(path.dirname(args.path)))
+                                .replace(/\b__filename\b/g, JSON.stringify(args.path))
+                        };
+                    });
+                }
+            }
+        ]
+    });
+    const { text } = result.outputFiles[0];
+    return {
+        code: text,
+        dependencies: result.metafile ? Object.keys(result.metafile.inputs) : []
+    };
+}
 export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mode = 'production', framework = 'vue', pwa = false }) => {
     const { getAppDir, getCliDir, getCliViteDir, getSrcDir, getCwd } = await import('./app-urls.js');
     if (!appDir) {
@@ -24,17 +101,7 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
     const cliDir = getCliDir();
     const cliViteDir = getCliViteDir(cliDir);
     const frameworkDir = new URL(`${framework}/`, cliViteDir);
-    const localPackages = ['vue', 'vue-router'];
-    const cliPackages = ['vitest'];
-    const packageUrls = {};
-    await (async () => {
-        for (const val of localPackages)
-            packageUrls[val] = getPkgJsonDir(new URL(await resolve(val, appDir.href)));
-    })();
-    await (async () => {
-        for (const val of cliPackages)
-            packageUrls[val] = getPkgJsonDir(new URL(await resolve(val, cliDir.href)));
-    })();
+    const fastifyDir = new URL('fastify/', cliViteDir);
     if (!publicDir)
         publicDir = new URL('public/', appDir);
     /**
@@ -42,18 +109,46 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
      */
     let vitrifyConfig;
     try {
-        vitrifyConfig = (await import(new URL('vitrify.config.js', appDir).pathname)).default;
+        if (fs.existsSync(new URL('vitrify.config.ts', appDir).pathname)) {
+            const configPath = new URL('vitrify.config.ts', appDir).pathname;
+            const bundledConfig = await bundleConfigFile(new URL('vitrify.config.ts', appDir).pathname);
+            fs.writeFileSync(configPath + '.js', bundledConfig.code);
+            vitrifyConfig = (await import(configPath + '.js')).default;
+            // fs.unlinkSync(configPath + '.js')
+        }
+        else {
+            vitrifyConfig = (await import(new URL('vitrify.config.js', appDir).pathname)).default;
+        }
         if (typeof vitrifyConfig === 'function')
-            vitrifyConfig = vitrifyConfig({ mode, command });
+            vitrifyConfig = await vitrifyConfig({ mode, command });
     }
     catch (e) {
-        console.error(e);
-        console.log('No vitrify.config.js file found, using defaults');
+        console.log('No vitrify.config.(ts|js) file found, using defaults');
         vitrifyConfig = {};
     }
-    let { productName = 'Product name' } = JSON.parse(readFileSync(new URL('package.json', appDir).pathname, {
-        encoding: 'utf-8'
-    }));
+    const localPackages = ['vue', 'vue-router'];
+    const cliPackages = [];
+    const packageUrls = vitrifyConfig.vitrify?.urls?.packages || {};
+    await (async () => {
+        for (const val of localPackages)
+            packageUrls[val] = getPkgJsonDir(new URL(await resolve(val, appDir.href)));
+    })();
+    // await (async () => {
+    //   for (const val of cliPackages)
+    //     packageUrls[val] = getPkgJsonDir(
+    //       new URL(await resolve(val, cliDir!.href))
+    //     )
+    // })()
+    let productName = 'Product name';
+    try {
+        ;
+        ({ productName } = JSON.parse(readFileSync(new URL('package.json', appDir).pathname, {
+            encoding: 'utf-8'
+        })));
+    }
+    catch (e) {
+        console.error('package.json not found');
+    }
     const ssrTransformCustomDir = () => {
         return {
             props: [],
@@ -73,13 +168,14 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
     let onBootHooks;
     let onRenderedHooks;
     let onMountedHooks;
-    let onSetupHooks;
+    let onSetupFiles;
     let globalCss;
     let staticImports;
     let sassVariables;
     let additionalData;
     const plugins = [
         vuePlugin({
+            compiler: await import('vue/compiler-sfc'),
             template: {
                 ssr: !!ssr,
                 compilerOptions: {
@@ -107,7 +203,7 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
                 onBootHooks = config.vitrify?.hooks?.onBoot || [];
                 onRenderedHooks = config.vitrify?.hooks?.onRendered || [];
                 onMountedHooks = config.vitrify?.hooks?.onMounted || [];
-                onSetupHooks = config?.vitrify?.hooks?.onSetup || [];
+                onSetupFiles = config?.vitrify?.hooks?.onSetup || [];
                 globalCss = config.vitrify?.globalCss || [];
                 staticImports = config.vitrify?.staticImports || {};
                 sassVariables = config.vitrify?.sass?.variables || {};
@@ -134,9 +230,16 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
             },
             resolveId(id) {
                 if (VIRTUAL_MODULES.includes(id))
-                    return id;
+                    return { id, moduleSideEffects: false };
                 return;
             },
+            transform: (code, id) => {
+                if (id.endsWith('main.ts') && id.includes('vitrify')) {
+                    code =
+                        `${globalCss.map((css) => `import '${css}'`).join('\n')}\n` + code;
+                }
+                return code;
+            },
             load(id) {
                 if (id === 'virtual:vitrify-hooks') {
                     return `export const onBoot = [${onBootHooks
@@ -148,12 +251,22 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
             export const onRendered = [${onRenderedHooks
                         .map((fn) => `${String(fn)}`)
                         .join(', ')}]
-            export const onSetup = [${onSetupHooks
-                        .map((fn) => `${String(fn)}`)
-                        .join(', ')}]`;
-                }
-                else if (id === 'virtual:global-css') {
-                    return `${globalCss.map((css) => `import '${css}'`).join('\n')}`;
+            export const onSetup = []
+            ${onSetupFiles
+                        .map((url, index) => `import ${url.pathname
+                        .replaceAll('/', '')
+                        .replaceAll('.', '')} from '${url.pathname}'; onSetup.push(${url.pathname
+                        .replaceAll('/', '')
+                        .replaceAll('.', '')})`)
+                        .join('\n')}`;
+                    // export const onSetup = [${onSetupHooks
+                    //   .map((fn) => `${String(fn)}`)
+                    //   .join(', ')}]`
+                    /**
+                     * CSS imports in virtual files do not seem to work. Using transform() instead
+                     */
+                    // } else if (id === 'virtual:global-css') {
+                    //   return `${globalCss.map((css) => `import '${css}'`).join('\n')}`
                 }
                 else if (id === 'virtual:static-imports') {
                     return `${Object.entries(staticImports)
@@ -188,6 +301,9 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
                         case 'client':
                             entry = new URL('ssr/entry-client.ts', frameworkDir).pathname;
                             break;
+                        case 'fastify':
+                            entry = new URL('entry.ts', fastifyDir).pathname;
+                            break;
                         default:
                             entry = new URL('csr/entry.ts', frameworkDir).pathname;
                     }
@@ -221,18 +337,91 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
         { find: 'cwd', replacement: cwd.pathname },
         { find: 'boot', replacement: new URL('boot/', srcDir).pathname },
         { find: 'assets', replacement: new URL('assets/', srcDir).pathname },
-        { find: 'vue', replacement: packageUrls['vue'].pathname },
-        { find: 'vue-router', replacement: packageUrls['vue-router'].pathname },
-        { find: 'vitrify', replacement: cliDir.pathname }
+        ...Object.entries(packageUrls).map(([key, value]) => ({
+            find: key,
+            replacement: value.pathname
+        }))
+        // { find: 'vue', replacement: packageUrls['vue'].pathname },
+        // { find: 'vue-router', replacement: packageUrls['vue-router'].pathname },
+        // { find: 'vitrify', replacement: cliDir.pathname }
     ];
     if (command === 'test')
         alias.push({
             find: 'vitest',
-            replacement: packageUrls.vitest.pathname
+            replacement: new URL(await resolve('vitest', cliDir.href)).pathname
         });
+    let rollupOptions;
+    let noExternal = [];
+    const external = [...builtinModules, ...serverModules];
+    if (ssr === 'server') {
+        rollupOptions = {
+            input: [
+                new URL('ssr/entry-server.ts', frameworkDir).pathname,
+                new URL('ssr/prerender.ts', frameworkDir).pathname,
+                new URL('ssr/server.ts', frameworkDir).pathname
+            ],
+            external,
+            output: {
+                minifyInternalExports: false,
+                entryFileNames: '[name].mjs',
+                chunkFileNames: '[name].mjs',
+                // format: 'es',
+                manualChunks: (id) => {
+                    if (id.includes('vitrify/src/vite/')) {
+                        const name = id.split('/').at(-1)?.split('.').at(0);
+                        if (name && manualChunks.includes(name))
+                            return name;
+                    }
+                    else if (id.includes('node_modules')) {
+                        return 'vendor';
+                    }
+                }
+            }
+        };
+        // Create a SSR bundle
+        noExternal = [
+            new RegExp(`^(?!(${[...builtinModules, ...serverModules].join('|')}))`)
+            // new RegExp(`^(?!.*(${[...builtinModules, ...serverModules].join('|')}))`)
+        ];
+    }
+    else if (ssr === 'fastify') {
+        rollupOptions = {
+            input: [new URL('server.ts', fastifyDir).pathname],
+            external,
+            output: {
+                minifyInternalExports: false,
+                entryFileNames: '[name].mjs',
+                chunkFileNames: '[name].mjs',
+                // format: 'es',
+                manualChunks: (id) => {
+                    if (id.includes('vitrify/src/vite/')) {
+                        const name = id.split('/').at(-1)?.split('.').at(0);
+                        if (name && manualChunks.includes(name))
+                            return name;
+                    }
+                    else if (id.includes('node_modules')) {
+                        return 'vendor';
+                    }
+                }
+            }
+        };
+        // Create a SSR bundle
+        noExternal = [
+            new RegExp(`^(?!(${[...builtinModules, ...serverModules].join('|')}))`)
+        ];
+    }
+    else {
+        rollupOptions = {
+        // input: [new URL('index.html', frameworkDir).pathname],
+        // output: {
+        //   format: 'es'
+        // }
+        };
+    }
     const config = {
-        root: frameworkDir.pathname,
+        root: ssr === 'fastify' ? appDir.pathname : frameworkDir.pathname,
         publicDir: publicDir.pathname,
+        envDir: appDir.pathname,
         vitrify: {
             productName,
             urls: {
@@ -245,7 +434,7 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
         },
         plugins,
         optimizeDeps: {
-            exclude: ['vue']
+            exclude: ['vue', ...serverModules, ...builtinModules]
         },
         resolve: {
             // Dedupe uses require which breaks ESM SSR builds
@@ -256,45 +445,42 @@ export const baseConfig = async ({ ssr, appDir, publicDir, command = 'build', mo
             alias
         },
         build: {
-            target: ssr === 'server' ? 'esnext' : 'modules',
-            ssr: ssr === 'server' ? true : false,
+            target: ssr === 'server' || ssr === 'fastify' ? 'esnext' : 'modules',
+            ssr: ssr === 'server' || ssr === 'fastify' ? true : false,
             ssrManifest: ssr === 'client' || ssr === 'ssg',
-            rollupOptions: ssr === 'server'
-                ? {
-                    input: [
-                        new URL('ssr/entry-server.ts', frameworkDir).pathname,
-                        new URL('ssr/prerender.ts', frameworkDir).pathname,
-                        new URL('ssr/server.ts', frameworkDir).pathname
-                    ],
-                    output: {
-                        minifyInternalExports: false,
-                        entryFileNames: '[name].mjs',
-                        chunkFileNames: '[name].mjs',
-                        format: 'es',
-                        manualChunks: (id) => {
-                            if (id.includes('vitrify/src/vite/')) {
-                                const name = id.split('/').at(-1)?.split('.').at(0);
-                                console.log(name);
-                                if (manualChunks.includes(id))
-                                    return name;
-                            }
-                            else if (id.includes('node_modules')) {
-                                return 'vendor';
-                            }
-                        }
-                    }
-                }
-                : {
-                    output: {
-                        format: 'es'
-                    }
-                }
+            rollupOptions
+            // ssr === 'server'
+            //   ? {
+            //       input: [
+            //         new URL('ssr/entry-server.ts', frameworkDir).pathname,
+            //         new URL('ssr/prerender.ts', frameworkDir).pathname,
+            //         new URL('ssr/server.ts', frameworkDir).pathname
+            //       ],
+            //       output: {
+            //         minifyInternalExports: false,
+            //         entryFileNames: '[name].mjs',
+            //         chunkFileNames: '[name].mjs',
+            //         format: 'es',
+            //         manualChunks: (id) => {
+            //           if (id.includes('vitrify/src/vite/')) {
+            //             const name = id.split('/').at(-1)?.split('.').at(0)
+            //             if (name && manualChunks.includes(name)) return name
+            //           } else if (id.includes('node_modules')) {
+            //             return 'vendor'
+            //           }
+            //         }
+            //       }
+            //     }
+            //   : {
+            //       output: {
+            //         format: 'es'
+            //       }
+            //     }
         },
         ssr: {
             // Create a SSR bundle
-            noExternal: [
-                new RegExp(`^(?!.*(${[...builtinModules, ...serverModules].join('|')}))`)
-            ]
+            external,
+            noExternal
         },
         define: {
             __BASE_URL__: `'/'`

package/dist/plugins/quasar.js

@@ -61,7 +61,7 @@ export const QuasarPlugin = async ({ ssr = false, pwa = false }) => {
                         const quasarPlugins = await import('virtual:quasar-plugins');
                         // @ts-ignore
                         const directives = await import('quasar/src/directives.js');
-                        app.use(staticImports.Quasar, {
+                        app.use(staticImports?.Quasar, {
                             plugins: quasarPlugins,
                             directives
                         }, ssrContext);
@@ -137,9 +137,14 @@ export const QuasarPlugin = async ({ ssr = false, pwa = false }) => {
                                 replacement: new URL('src/', urls?.packages?.quasar).pathname
                             },
                             {
-                                find: 'quasar',
-                                replacement: new URL('src/', urls?.packages?.quasar).pathname
+                                find: new RegExp('^quasar$'),
+                                replacement: new URL('src/index.all.js', urls?.packages?.quasar)
+                                    .pathname
                             },
+                            // {
+                            //   find: 'quasar',
+                            //   replacement: new URL('src/index.all.js', urls?.packages?.quasar).pathname
+                            // },
                             {
                                 find: `@quasar/extras`,
                                 replacement: new URL('.', urls?.packages?.['@quasar/extras'])
@@ -167,7 +172,7 @@ export const QuasarPlugin = async ({ ssr = false, pwa = false }) => {
             config: async (config, env) => ({
                 resolve: {
                     alias: [
-                        { find: new RegExp('^quasar$'), replacement: 'virtual:quasar' }
+                    // { find: new RegExp('^quasar$'), replacement: 'virtual:quasar' }
                     ]
                 }
             }),

package/dist/types/bin/build.d.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/node --experimental-specifier-resolution=node
 export declare function build(opts: {
-    ssr?: 'client' | 'server' | 'ssg';
+    ssr?: 'client' | 'server' | 'ssg' | 'fastify';
     base?: string;
-    outDir?: string;
+    outDir: string;
     appDir?: URL;
     publicDir?: URL;
 }): Promise<import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher>;

package/dist/types/bin/dev.d.ts

@@ -1,15 +1,51 @@
 /// <reference types="node" />
-import type { ViteDevServer, LogLevel } from 'vite';
+import type { LogLevel, InlineConfig } from 'vite';
+import { ViteDevServer } from 'vite';
 import type { Server } from 'net';
+export declare function createVitrifyDevServer({ port, logLevel, mode, framework, host, appDir, publicDir }: {
+    port?: number;
+    logLevel?: LogLevel;
+    mode?: 'csr' | 'ssr' | 'fastify';
+    framework?: 'vue';
+    host?: string;
+    appDir?: URL;
+    publicDir?: URL;
+}): Promise<ViteDevServer>;
 export declare function createServer({ port, logLevel, mode, framework, host, appDir, publicDir }: {
     port?: number;
     logLevel?: LogLevel;
-    mode?: 'csr' | 'ssr';
+    mode?: 'csr' | 'ssr' | 'fastify';
     framework?: 'vue';
     host?: string;
     appDir?: URL;
     publicDir?: URL;
 }): Promise<{
     server: Server;
-    vite: ViteDevServer;
+    config: Readonly<Omit<import("vite").UserConfig, "plugins" | "assetsInclude" | "optimizeDeps" | "worker"> & {
+        configFile: string | undefined;
+        configFileDependencies: string[];
+        inlineConfig: InlineConfig;
+        root: string;
+        base: string;
+        publicDir: string;
+        cacheDir: string;
+        command: "build" | "serve";
+        mode: string;
+        isWorker: boolean;
+        isProduction: boolean;
+        env: Record<string, any>;
+        resolve: import("vite").ResolveOptions & {
+            alias: import("vite").Alias[];
+        };
+        plugins: readonly import("vite").Plugin[];
+        server: import("vite").ResolvedServerOptions;
+        build: Required<import("vite").BuildOptions>;
+        preview: import("vite").ResolvedPreviewOptions;
+        assetsInclude: (file: string) => boolean;
+        logger: import("vite").Logger;
+        createResolver: (options?: Partial<import("vite").InternalResolveOptions> | undefined) => import("vite").ResolveFn;
+        optimizeDeps: import("vite").DepOptimizationOptions;
+        worker: import("vite").ResolveWorkerOptions;
+        spa: boolean;
+    }>;
 }>;

package/dist/types/frameworks/vue/fastify-ssr-plugin.d.ts

@@ -1,14 +1,17 @@
 import type { FastifyPluginCallback, FastifyRequest, FastifyReply } from 'fastify';
-import type { ViteDevServer } from 'vite';
 import type { OnRenderedHook } from '../../vitrify-config.js';
+import type { ViteDevServer } from 'vite';
 export interface FastifySsrOptions {
     baseUrl?: string;
     provide?: (req: FastifyRequest, res: FastifyReply) => Promise<Record<string, unknown>>;
+    vitrifyDir?: URL;
     vite?: ViteDevServer;
-    cliDir?: URL;
     appDir?: URL;
+    publicDir?: URL;
     productName?: string;
-    onRenderedHooks?: OnRenderedHook[];
+    onRendered?: OnRenderedHook[];
+    mode?: string;
 }
 declare const fastifySsrPlugin: FastifyPluginCallback<FastifySsrOptions>;
 export { fastifySsrPlugin };
+export declare type FastifySsrPlugin = typeof fastifySsrPlugin;

package/dist/types/frameworks/vue/server.d.ts

@@ -1,9 +1,13 @@
 /// <reference types="node" />
 import type { FastifyInstance } from 'fastify';
-import type { OnRenderedHook } from '../../vitrify-config.js';
-export declare const createApp: ({ setup, appDir, baseUrl, onRenderedHooks }: {
-    setup: (fastify: FastifyInstance) => any;
+import type { OnRenderedHook, OnSetupFile } from '../../vitrify-config.js';
+import type { FastifySsrPlugin } from './fastify-ssr-plugin.js';
+export declare const createApp: ({ onSetup, appDir, baseUrl, onRendered, fastifySsrPlugin, vitrifyDir, mode }: {
+    onSetup: OnSetupFile[];
     appDir: URL;
     baseUrl?: string | undefined;
-    onRenderedHooks?: OnRenderedHook[] | undefined;
-}) => FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance> & PromiseLike<FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance>>;
+    onRendered?: OnRenderedHook[] | undefined;
+    fastifySsrPlugin: FastifySsrPlugin;
+    vitrifyDir?: URL | undefined;
+    mode: string;
+}) => FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, pino.Logger, import("fastify").FastifyTypeProviderDefault> & PromiseLike<FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, pino.Logger, import("fastify").FastifyTypeProviderDefault>>;

package/dist/types/helpers/collect-css-ssr.d.ts

@@ -0,0 +1,10 @@
+import type { ViteDevServer, ModuleNode } from 'vite';
+/**
+ * Collect SSR CSS for Vite
+ */
+export declare const componentsModules: (components: string[], vite: ViteDevServer) => Set<ModuleNode>;
+export declare const collectCss: (mods: Set<ModuleNode>, styles?: Map<string, string>, checkedComponents?: Set<unknown>) => string;
+/**
+ * Client listener to detect updated modules through HMR, and remove the initial styled attached to the head
+ */
+export declare const removeCssHotReloaded: () => void;

package/dist/types/helpers/routes.d.ts

@@ -1,2 +1,2 @@
 import type { RouteRecordRaw } from 'vue-router';
-export declare const routesToPaths: (routes?: RouteRecordRaw[] | undefined) => string[];
+export declare const routesToPaths: (routes?: RouteRecordRaw[]) => string[];

package/dist/types/index.d.ts

@@ -4,7 +4,7 @@ import type { VitrifyContext } from './bin/run.js';
 import type { VitrifyPlugin } from './plugins/index.js';
 export declare const VIRTUAL_MODULES: string[];
 export declare const baseConfig: ({ ssr, appDir, publicDir, command, mode, framework, pwa }: {
-    ssr?: "server" | "client" | "ssg" | undefined;
+    ssr?: "server" | "client" | "ssg" | "fastify" | undefined;
     appDir?: URL | undefined;
     publicDir?: URL | undefined;
     command?: "build" | "dev" | "test" | undefined;

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

@@ -1,6 +1,6 @@
 import type { Plugin } from 'vite';
 export declare type VitrifyPlugin = ({ ssr, mode, command }: {
-    ssr?: 'server' | 'client' | 'ssg' | false;
+    ssr?: 'server' | 'client' | 'ssg' | 'fastify' | false;
     pwa?: boolean;
     mode?: 'production' | 'development';
     command?: 'build' | 'dev' | 'test';

package/dist/types/vitrify-config.d.ts

@@ -1,4 +1,3 @@
-import type { FastifyInstance } from 'fastify';
 import type { UserConfig } from 'vite';
 import type { QuasarConf } from './plugins/quasar.js';
 import type { ComponentInternalInstance } from '@vue/runtime-core';
@@ -10,13 +9,13 @@ export declare type BootFunction = ({ app, ssrContext, staticImports }: {
 export declare type OnBootHook = ({ app, ssrContext, staticImports }: {
     app: any;
     ssrContext: Record<string, unknown>;
-    staticImports: Record<string, any>;
+    staticImports?: Record<string, any>;
 }) => Promise<void> | void;
 export declare type OnMountedHook = (instance: ComponentInternalInstance) => Promise<void> | void;
 export declare type StaticImports = Record<string, string[]>;
 export declare type SsrFunction = (html: string, ssrContext: Record<string, any>) => string;
 export declare type OnRenderedHook = (html: string, ssrContext: Record<string, any>) => string;
-export declare type OnSetupHook = (fastify: FastifyInstance) => any;
+export declare type OnSetupFile = URL;
 export interface VitrifyConfig extends UserConfig {
     vitrify?: {
         /**
@@ -31,7 +30,7 @@ export interface VitrifyConfig extends UserConfig {
             /**
              * setup() is called directly after instantiating fastify. Use it to register your own plugins, routes etc.
              */
-            onSetup?: OnSetupHook[];
+            onSetup?: OnSetupFile[];
             /**
              * Functions which run in the onMounted hook of the app
              */