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

package/src/core/nitro.ts

@@ -1,206 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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;
-}