@monkeyplus/flow 5.0.0-rc.199 → 5.0.0-rc.2

package/src/core/nitro.ts

@@ -0,0 +1,206 @@
+import { existsSync, promises as fsp } from 'node:fs';
+import {
+  build,
+  copyPublicAssets,
+  createDevServer,
+  createNitro,
+  prepare,
+  prerender,
+  scanHandlers,
+  writeTypes,
+
+} from 'nitropack';
+import fsExtra from 'fs-extra';
+import type { NitroConfig, NitroDevEventHandler, NitroEventHandler } from 'nitropack';
+import defu from 'defu';
+import { join, resolve } from 'pathe';
+import type { Flow } from '@monkeyplus/flow-schema';
+import { dynamicEventHandler, toEventHandler } from 'h3';
+// import { debounce } from 'perfect-debounce';
+import { distDir } from '../dirs';
+import { ImportProtectionPlugin } from './plugins/import-protection';
+
+export async function initNitro(flow: Flow): Promise<void> {
+  const { handlers, devHandlers } = await resolveHandlers(flow);
+
+  const _nitroConfig = ((flow.options as any).nitro || {}) as NitroConfig;
+  // const vite = await createVite(flow);
+  globalThis.generate = {};
+  const nitroConfig: NitroConfig = defu(_nitroConfig, <NitroConfig>{
+    rootDir: flow.options.rootDir,
+    srcDir: join(flow.options.srcDir, 'server'),
+    dev: flow.options.dev,
+    preset: flow.options.dev ? 'nitro-dev' : undefined,
+    buildDir: flow.options.buildDir,
+    scanDirs: flow.options._layers.map((layer) => join(layer.config.srcDir, 'server')),
+    renderer: resolve(distDir, 'core/runtime/nitro/renderer'),
+    // errorHandler: resolve(distDir, 'core/runtime/nitro/error'),
+    nodeModulesDirs: flow.options.modulesDir,
+    handlers,
+    devHandlers: [
+
+    ],
+    baseURL: flow.options.app.baseURL,
+    runtimeConfig: {
+      ...flow.options.runtimeConfig,
+      app: {
+        ...flow.options.runtimeConfig.app,
+        rootDir: flow.options.rootDir,
+        locale: flow.options.locale,
+      },
+      nitro: {
+        envPrefix: 'FLOW_',
+        ...flow.options.runtimeConfig.nitro,
+      },
+      generate: flow.options._generate,
+    },
+    typescript: {
+      generateTsConfig: false,
+    },
+    publicAssets: [
+      {
+        baseURL: flow.options.app.buildAssetsDir,
+        dir: resolve(flow.options.buildDir, 'dist/client'),
+      },
+      ...flow.options._layers
+        .map((layer) => join(layer.config.srcDir, layer.config.dir?.public || 'public'))
+        .filter((dir) => existsSync(dir))
+        .map((dir) => ({ dir })),
+    ],
+    prerender: {
+      crawlLinks: flow.options._generate ? flow.options.generate.crawler : false,
+      routes: []
+        .concat(flow.options._generate ? ['/_urls', ...flow.options.generate.routes] : []),
+    },
+    sourcemap: flow.options.sourcemap,
+    externals: {
+      inline: [
+        ...(flow.options.dev ? [] : ['eta', '@monkeyplus/', '@vue/', '@nuxt/', flow.options.buildDir]),
+        '@monkeyplus/flow/dist',
+      ],
+    },
+    alias: {
+
+      // Vue 3 mocks
+      'estree-walker': 'unenv/runtime/mock/proxy',
+      '@babel/parser': 'unenv/runtime/mock/proxy',
+      // Paths
+      '#paths': resolve(distDir, 'core/runtime/nitro/paths'),
+      // Shortcut to server main file
+      '#server': '#build/dist/server/server.mjs',
+      //* App dir
+      '#app': flow.options.appDir,
+
+      // Nuxt aliases
+      ...flow.options.alias,
+    },
+    rollupConfig: {
+      plugins: [],
+    },
+
+  });
+  await flow.callHook('nitro:config', nitroConfig);
+
+  // Base middleware
+  nitroConfig.handlers.unshift({
+    middleware: true,
+    handler: resolve(distDir, 'core/runtime/nitro/flow'),
+  });
+
+  // Extend nitro config with hook
+
+  const nitro = await createNitro(nitroConfig);
+
+  // Expose nitro to modules
+  await flow.callHook('nitro:init', nitro);
+
+  // Connect vfs storages
+  nitro.vfs = flow.vfs = nitro.vfs || flow.vfs || {};
+
+  // Connect hooks
+  flow.hook('close', () => nitro.hooks.callHook('close'));
+
+  // Register flow protection patterns
+  nitro.hooks.hook('rollup:before', (nitro) => {
+    const plugin = ImportProtectionPlugin.rollup({
+      rootDir: flow.options.rootDir,
+      patterns: [
+        ...['#app', /^#build(\/|$)/]
+          .map((p) => [p, 'Flow app aliases are not allowed in server routes.']) as [RegExp | string, string][],
+      ],
+    });
+    nitro.options.rollupConfig.plugins.push(plugin);
+  });
+  // Setup handlers
+  const devMidlewareHandler = dynamicEventHandler();
+  nitro.options.devHandlers.unshift({ handler: devMidlewareHandler });
+  nitro.options.devHandlers.push(...devHandlers);
+  nitro.options.handlers.unshift({
+    route: '/__flow_error',
+    lazy: true,
+    handler: resolve(distDir, 'core/runtime/nitro/renderer'),
+  });
+  // Add typed route responses
+  flow.hook('prepare:types', async(opts) => {
+    if (flow.options._prepare) {
+      await scanHandlers(nitro);
+      await writeTypes(nitro);
+    }
+    opts.references.push({ path: resolve(flow.options.buildDir, 'types/nitro.d.ts') });
+  });
+
+  flow.hook('build:done', async() => {
+    await flow.callHook('nitro:build:before', nitro);
+    // console.log(nitro.options._config, nitro.vfs['#build/dist/server/server.mjs']);
+
+    if (flow.options.dev) {
+      await build(nitro);
+    }
+    else {
+      await prepare(nitro);
+
+      await copyPublicAssets(nitro);
+
+      await prerender(nitro);
+      if (!flow.options._generate) {
+        await build(nitro);
+      }
+      else {
+        // TODO: refactor to nuxt
+        const nitroDev = await createNitro({
+          ...nitro.options._config,
+          rootDir: nitro.options.rootDir,
+          logLevel: 0,
+          preset: 'nitro-prerender',
+        });
+        flow.server = nitroDev;
+
+        const distDir = resolve(flow.options.rootDir, 'dist');
+        if (!existsSync(distDir))
+          await fsp.symlink(nitro.options.output.publicDir, distDir, 'junction').catch(() => {});
+      }
+    }
+  });
+  if (flow.options.dev) {
+    flow.hook('build:compile', ({ compiler }) => {
+      compiler.outputFileSystem = { ...fsExtra, join } as any;
+    });
+    flow.hook('server:devMiddleware', (m) => { devMidlewareHandler.set(toEventHandler(m)); });
+    flow.server = createDevServer(nitro);
+    flow.hook('build:resources', () => {
+      flow.server.reload();
+    });
+    const waitUntilCompile = new Promise<void>((resolve) => nitro.hooks.hook('compiled', () => resolve()));
+    flow.hook('build:done', () => waitUntilCompile);
+  }
+}
+
+async function resolveHandlers(flow: Flow) {
+  const handlers: NitroEventHandler[] = [...flow.options.serverHandlers];
+  const devHandlers: NitroDevEventHandler[] = [...flow.options.devServerHandlers];
+
+  return {
+    handlers,
+    devHandlers,
+  };
+}

package/src/core/plugins/import-protection.ts

@@ -0,0 +1,49 @@
+import { createRequire } from 'node:module';
+import { createUnplugin } from 'unplugin';
+import { logger } from '@monkeyplus/flow-kit';
+import { isAbsolute, relative } from 'pathe';
+
+const _require = createRequire(import.meta.url);
+
+interface ImportProtectionOptions {
+  rootDir: string
+  patterns: [importPattern: string | RegExp, warning?: string][]
+}
+
+// export const vueAppPatterns = (flow: Flow) => [
+//   [/^(nuxt3|nuxt)$/, '`nuxt3`/`nuxt` cannot be imported directly. Instead, import runtime Nuxt composables from `#app` or `#imports`.'],
+//   [/nuxt\.config/, 'Importing directly from a `nuxt.config` file is not allowed. Instead, use runtime config or a module.'],
+//   [/(^|node_modules\/)@vue\/composition-api/],
+//   ...nuxt.options.modules.filter((m) => typeof m === 'string').map((m: string) =>
+//     [new RegExp(`^${escapeRE(m)}$`), 'Importing directly from module entry points is not allowed.']),
+//   ...[/(^|node_modules\/)@nuxt\/kit/, /^nitropack/]
+//     .map((i) => [i, 'This module cannot be imported in the Vue part of your app.']),
+//   [new RegExp(escapeRE(resolve(nuxt.options.srcDir, (nuxt.options.dir as any).server || 'server'))), 'Importing from server middleware is not allowed in the Vue part of your app.'],
+// ] as ImportProtectionOptions['patterns'];
+
+export const ImportProtectionPlugin = createUnplugin((options: ImportProtectionOptions) => {
+  const cache: Record<string, Map<string | RegExp, boolean>> = {};
+  return {
+    name: 'flow:import-protection',
+    enforce: 'pre',
+    resolveId(id, importer) {
+      const invalidImports = options.patterns.filter(([pattern]) => pattern instanceof RegExp ? pattern.test(id) : pattern === id);
+      let matched: boolean;
+      for (const match of invalidImports) {
+        cache[id] = cache[id] || new Map();
+        const [pattern, warning] = match;
+        // Skip if already warned
+        if (cache[id].has(pattern)) continue;
+
+        const relativeImporter = isAbsolute(importer) ? relative(options.rootDir, importer) : importer;
+        logger.error(warning || 'Invalid import', `[importing \`${id}\` from \`${relativeImporter}\`]`);
+        cache[id].set(pattern, true);
+        matched = true;
+      }
+      if (matched)
+        return _require.resolve('unenv/runtime/mock/proxy');
+
+      return null;
+    },
+  };
+});

package/src/core/plugins/unctx.ts

@@ -0,0 +1,31 @@
+import type { Nuxt, NuxtApp, NuxtMiddleware } from '@monkeyplus/flow-schema';
+import { createTransformer } from 'unctx/transform';
+import { createUnplugin } from 'unplugin';
+
+export const UnctxTransformPlugin = (nuxt: Nuxt) => {
+  const transformer = createTransformer({
+    asyncFunctions: ['defineNuxtPlugin', 'defineNuxtRouteMiddleware'],
+  });
+
+  let app: NuxtApp | undefined;
+  let middleware: NuxtMiddleware[] = [];
+  nuxt.hook('app:resolve', (_app) => { app = _app; });
+  nuxt.hook('pages:middleware:extend', (_middlewares) => { middleware = _middlewares; });
+
+  return createUnplugin((options: { sourcemap?: boolean } = {}) => ({
+    name: 'unctx:transfrom',
+    enforce: 'post',
+    transformInclude(id) {
+      return Boolean(app?.plugins.find((i) => i.src === id) || middleware.find((m) => m.path === id));
+    },
+    transform(code, id) {
+      const result = transformer.transform(code);
+      if (result) {
+        return {
+          code: result.code,
+          map: options.sourcemap && result.magicString.generateMap({ source: id, includeContent: true }),
+        };
+      }
+    },
+  }));
+};

package/src/core/runtime/nitro/flow.ts

@@ -0,0 +1,43 @@
+import { defineEventHandler } from 'h3';
+// TODO: remove in node 18
+import 'node-fetch-native/polyfill';
+
+// @ts-ignore
+import { useRuntimeConfig } from '#internal/nitro';
+
+// @ts-ignore
+const getServerApp = cachedImport(() => import('#server'));
+
+const getFlowRenderer = cachedResult(async() => {
+  // Load server bundle
+  const createFlowApp = await getServerApp();
+
+  if (!createFlowApp) throw new Error('Server bundle is not available');
+  // Create renderer
+  return createFlowApp(useRuntimeConfig());
+});
+
+export default defineEventHandler(async({ context }) => {
+  const flow = await getFlowRenderer(); // const flow = module.default(_config);
+  context.flow = flow;
+  context.render = flow.render;
+});
+
+function _interopDefault(e: any) {
+  return e && typeof e === 'object' && 'default' in e ? e.default : e;
+}
+
+function cachedImport <M>(importer: () => Promise<M>) {
+  return cachedResult(() => importer().then(_interopDefault).then(_interopDefault)) as () => Promise<M>;
+}
+
+function cachedResult <T>(fn: () => Promise<T>): () => Promise<T> {
+  let res: Promise<T> | null = null;
+  // console.log(res);
+  return () => {
+    if (res === null)
+      res = fn().catch((err) => { res = null; throw err; });
+
+    return res;
+  };
+}

package/src/core/runtime/nitro/paths.ts

@@ -0,0 +1,20 @@
+import { joinURL } from 'ufo';
+// @ts-ignore
+import { useRuntimeConfig } from '#internal/nitro';
+
+export function baseURL(): string {
+  return useRuntimeConfig().app.baseURL;
+}
+
+export function buildAssetsDir(): string {
+  return useRuntimeConfig().app.buildAssetsDir;
+}
+
+export function buildAssetsURL(...path: string[]): string {
+  return joinURL(publicAssetsURL(), useRuntimeConfig().app.buildAssetsDir, ...path);
+}
+
+export function publicAssetsURL(...path: string[]): string {
+  const publicBase = useRuntimeConfig().app.cdnURL || useRuntimeConfig().app.baseURL;
+  return path.length ? joinURL(publicBase, ...path) : publicBase;
+}

package/src/core/runtime/nitro/renderer.ts

@@ -0,0 +1,74 @@
+import { eventHandler, useQuery } from 'h3';
+import type{ FlowApp } from '#app/flow';
+
+export default eventHandler(async(event) => {
+  const url = event.req.url?.split('?')[0];
+
+  // console.debug(url);
+
+  const flow = event.context.flow as FlowApp;
+  if (url.includes('_urls')) {
+    const urls = await flow.app.utils.getUrls();
+    return urls;
+  }
+  const scripts = { head: [], bodyStart: [], bodyEnd: [] };
+  const chunks = { head: [], body: [] };
+  const generate = {};
+
+  // console.log(flow);
+  const { page, locale, params, view } = flow.router.byUrl.lookup(url!) || {};
+  // Truncate page
+  if (!page) return;
+
+  await flow.callHook('page:scripts', scripts);
+  if (view.bundle)
+    await flow.callHook('page:chunks', view.bundle, chunks);
+
+  const templateContext = {} as any;
+
+  const dynamyc = params?._;
+  const contextPage = {} as any;
+  const utils = Object.assign({ getLocale: () => locale }, flow.app.utils);
+  templateContext.url = url;
+  templateContext.locale = locale;
+  templateContext.view = view;
+
+  if (dynamyc && page.dynamic) {
+    const pages = await page.dynamic.method({ locale, utils });
+    const dynamicPage = pages.find((_page) => _page.url === dynamyc);
+    if (!dynamicPage) return;
+    if (page.dynamic.assign)
+      templateContext[page.dynamic.assign] = dynamicPage.context;
+
+    contextPage.dynamyc = dynamicPage;
+  }
+
+  templateContext.seo = {};
+  templateContext.context = {};
+  templateContext.sharedContext = {};
+  templateContext.utils = utils;
+  templateContext.seo = await page.seo?.({ ...contextPage, utils }) || {};
+  templateContext.context = await page.context?.({ ...contextPage, utils }) || {};
+  templateContext.getHeadScripts = () => {
+    return scripts.head.join('\n');
+  };
+  templateContext.getHeadChunks = () => {
+    return chunks.head.join('\n');
+  };
+  templateContext.getBodyChunks = () => {
+    return chunks.body.join('\n');
+  };
+  const query = useQuery(event);
+  if (query?.context)
+    return { ...templateContext, utils: Object.keys(utils) };
+
+  const html = await flow.render(view as any, templateContext);
+  event.res.setHeader('Content-Type', 'text/html;charset=UTF-8');
+
+  if (flow.generate) {
+    await flow.callHook('page:generate', generate);
+    globalThis.generate = generate;
+  }
+
+  return html;
+});

package/src/core/templates.ts

@@ -0,0 +1,119 @@
+import { templateUtils } from '@monkeyplus/flow-kit';
+import type { Nuxt, NuxtApp, NuxtTemplate } from '@monkeyplus/flow-schema';
+import { genArrayFromRaw, genDynamicImport, genString } from 'knitwork';
+import { isAbsolute, join, relative } from 'pathe';
+import { generateTypes, resolveSchema } from 'untyped';
+
+import escapeRE from 'escape-string-regexp';
+
+export interface TemplateContext {
+  nuxt: Nuxt
+  app: NuxtApp
+}
+// export const cssTemplate = {
+//   filename: 'css.mjs',
+//   getContents: (ctx: TemplateContext) => ctx.flow.options.css.map((i) => genImport(i)).join('\n'),
+// };
+
+export const serverPluginTemplate = {
+  filename: 'plugins/server.mjs',
+  getContents(ctx: TemplateContext) {
+    const serverPlugins = ctx.app.plugins;
+    return [
+      templateUtils.importSources(serverPlugins.map((p) => p.src)),
+      `export default ${genArrayFromRaw([
+        ...serverPlugins.map((p) => templateUtils.importName(p.src)),
+      ])}`,
+    ].join('\n');
+  },
+};
+
+export const pluginsDeclaration = {
+  filename: 'types/plugins.d.ts',
+  getContents: (ctx: TemplateContext) => {
+    // console.log(ctx);
+
+    const EXTENSION_RE = new RegExp(`(?<=\\w)(${ctx.nuxt.options.extensions.map((e) => escapeRE(e)).join('|')})$`, 'g');
+    const tsImports = ctx.app.plugins.map((p) => (isAbsolute(p.src) ? relative(join(ctx.nuxt.options.buildDir, 'types'), p.src) : p.src).replace(EXTENSION_RE, ''));
+
+    return `// Generated by Flow'
+import type { Plugin } from '#app'
+
+type Decorate<T extends Record<string, any>> = { [K in keyof T as K extends string ? \`$\${K}\` : never]: T[K] }
+
+type InjectionType<A extends Plugin> = A extends Plugin<infer T> ? Decorate<T> : unknown
+
+type FlowAppInjections = \n  ${tsImports.map((p) => `InjectionType<typeof ${genDynamicImport(p, { wrapper: false })}.default>`).join(' &\n  ')}
+
+declare module '#app' {
+  interface FlowApp extends FlowAppInjections { }
+}
+// TODO: Insert extend types
+
+
+export { }
+`;
+  },
+};
+
+const adHocModules = ['auto-imports', 'meta', 'pages', 'vite-client'];
+export const schemaTemplate = {
+  filename: 'types/schema.d.ts',
+  getContents: ({ nuxt }: TemplateContext) => {
+    const moduleInfo = nuxt.options._installedModules.map((m) => ({
+      ...m.meta || {},
+      importName: m.entryPath || m.meta?.name,
+    })).filter((m) => m.configKey && m.name && !adHocModules.includes(m.name));
+
+    return [
+      'import { FlowModule } from \'@monkeyplus/flow-schema\'',
+      'declare module \'@monkeyplus/flow-schema\' {',
+      '  interface FlowConfig {',
+      ...moduleInfo.filter(Boolean).map((meta) =>
+        `    [${genString(meta.configKey)}]?: typeof ${genDynamicImport(meta.importName, { wrapper: false })}.default extends FlowModule<infer O> ? Partial<O> : Record<string, any>`,
+      ),
+      '  }',
+      generateTypes(resolveSchema(Object.fromEntries(Object.entries(nuxt.options.runtimeConfig).filter(([key]) => key !== 'public'))),
+        {
+          interfaceName: 'RuntimeConfig',
+          addExport: false,
+          addDefaults: false,
+          allowExtraKeys: false,
+          indentation: 2,
+        }),
+      generateTypes(resolveSchema(nuxt.options.runtimeConfig.public),
+        {
+          interfaceName: 'PublicRuntimeConfig',
+          addExport: false,
+          addDefaults: false,
+          allowExtraKeys: false,
+          indentation: 2,
+        }),
+      '}',
+    ].join('\n');
+  },
+};
+
+export const publicPathTemplate: NuxtTemplate = {
+  filename: 'paths.mjs',
+  getContents({ nuxt }) {
+    return [
+      'import { joinURL } from \'ufo\'',
+      !nuxt.options.dev && 'import { useRuntimeConfig } from \'#internal/nitro\'',
+
+      nuxt.options.dev
+        ? `const appConfig = ${JSON.stringify(nuxt.options.app)}`
+        : 'const appConfig = useRuntimeConfig().app',
+
+      'export const baseURL = () => appConfig.baseURL',
+      'export const buildAssetsDir = () => appConfig.buildAssetsDir',
+
+      'export const buildAssetsURL = (...path) => joinURL(publicAssetsURL(), buildAssetsDir(), ...path)',
+
+      'export const publicAssetsURL = (...path) => {',
+      '  const publicBase = appConfig.cdnURL || appConfig.baseURL',
+      '  return path.length ? joinURL(publicBase, ...path) : publicBase',
+      '}',
+    ].filter(Boolean).join('\n');
+  },
+};

package/src/core/vite/builder/css.ts

@@ -0,0 +1,28 @@
+import { requireModule } from '@monkeyplus/flow-kit';
+import type { Flow } from '@monkeyplus/flow-schema';
+import { distDir } from '../../../dirs';
+import type { ViteOptions } from './types';
+
+export function resolveCSSOptions(flow: Flow): ViteOptions['css'] {
+  const css: ViteOptions['css'] & { postcss: Exclude<ViteOptions['css']['postcss'], string> } = {
+    postcss: {
+      plugins: [],
+    },
+  };
+
+  const lastPlugins = ['autoprefixer', 'cssnano'];
+  css.postcss.plugins = Object.entries(flow.options.postcss?.plugins || {})
+    .sort((a, b) => lastPlugins.indexOf(a[0]) - lastPlugins.indexOf(b[0]))
+    .filter(([, opts]) => opts)
+    .map(([name, opts]) => {
+      const plugin = requireModule(name, {
+        paths: [
+          ...flow.options.modulesDir,
+          distDir,
+        ],
+      });
+      return plugin(opts);
+    });
+
+  return css;
+}