phecda-server 7.0.0-alpha.9 → 7.0.0

package/register/loader.mjs

@@ -3,31 +3,45 @@ import { writeFile } from 'fs/promises'
 import {
   basename,
   dirname,
-  extname,
   isAbsolute,
   relative,
   resolve as resolvePath,
 } from 'path'
 import { createRequire } from 'module'
-import { existsSync } from 'fs'
 import ts from 'typescript'
 import chokidar from 'chokidar'
-import { IS_DEV, log } from '../dist/index.mjs'
+import Debug from 'debug'
 import { compile, genUnImportRet, handleClassTypes, slash } from './utils.mjs'
 
+const require = createRequire(import.meta.url)
+const debug = Debug('phecda-server/loader')
+
+const isLowVersion = parseFloat(process.version.slice(1)) < 18.19
+const IS_DEV = process.env.NODE_ENV === 'development'
 let port
+let config
+const workdir = process.cwd()
+const configPath = resolvePath(
+  workdir,
+  process.env.PS_CONFIG_FILE || 'ps.json',
+)
+
+// unimport
+let unimportRet, customLoad, customResolve
+const dtsPath = process.env.PS_DTS_PATH || 'ps.d.ts'
+
+// graph
+const watchFiles = new Set()
+const filesRecord = new Map()
+const moduleGraph = {}
+// ts
 let tsconfig = {
   module: ts.ModuleKind.ESNext,
   moduleResolution: ts.ModuleResolutionKind.NodeNext,
 }
-
-const isLowVersion = parseFloat(process.version.slice(1)) < 18.19
-// this part is important or not?
 const EXTENSIONS = [ts.Extension.Ts, ts.Extension.Tsx, ts.Extension.Mts]
-
 const tsconfigPath = resolvePath(process.cwd(), 'tsconfig.json')
 const tsRet = ts.readConfigFile(tsconfigPath, ts.sys.readFile)
-
 if (!tsRet.error) {
   const { error, options } = ts.parseJsonConfigFileContent(
     tsRet.config,
@@ -48,33 +62,31 @@ const host = {
   readFile: ts.sys.readFile,
 }
 
-let unimportRet
-const dtsPath = 'ps.d.ts'
-
 if (isLowVersion)
   await initialize()
 
-let config
-
-const workdir = process.cwd()
-
-const configPath = resolvePath(
-  workdir,
-  process.env.PS_CONFIG_FILE || 'ps.json',
-)
-
-const require = createRequire(import.meta.url)
 export async function initialize(data) {
   if (data)
     port = data.port
-  log('read config...')
+
+  debug('read config...')
 
   config = require(configPath)
-  if (!config.virtualFile)
-    config.virtualFile = {}
+
   if (!config.paths)
     config.paths = {}
 
+  const loaderPath = process.env.PS_LOADER_PATH
+
+  if (loaderPath) {
+    const loader = await import(loaderPath.startsWith('.') ? resolvePath(workdir, loaderPath) : loaderPath)
+
+    if (typeof loader.load === 'function')
+      customLoad = loader.load
+
+    if (typeof loader.resolve === 'function')
+      customResolve = loader.resolve
+  }
   if (IS_DEV) {
     chokidar.watch(configPath, { persistent: true }).on('change', () => {
       port.postMessage(
@@ -87,19 +99,21 @@ export async function initialize(data) {
 
   if (!config.unimport)
     return
+
   unimportRet = await genUnImportRet(config.unimport)
   if (unimportRet) {
-    log('auto import...')
+    debug('auto import...')
     await unimportRet.init()
 
+    const unimportDtsPath = resolvePath(workdir, dtsPath)
     writeFile(
-      resolvePath(workdir, config.unimport.dtsPath || dtsPath),
+      unimportDtsPath,
       handleClassTypes(
         await unimportRet.generateTypeDeclarations({
           resolvePath: (i) => {
             if (i.from.startsWith('.') || isAbsolute(i.from)) {
               const related = slash(
-                relative(workdir, i.from).replace(/\.ts(x)?$/, ''),
+                relative(dirname(unimportDtsPath), i.from).replace(/\.ts(x)?$/, ''),
               )
 
               return !related.startsWith('.') ? `./${related}` : related
@@ -112,12 +126,6 @@ export async function initialize(data) {
   }
 }
 
-const watchFiles = new Set()
-const filesRecord = new Map()
-const moduleGraph = {}
-
-let entryUrl
-
 function addUrlToGraph(url, parent) {
   if (!(url in moduleGraph))
     moduleGraph[url] = new Set()
@@ -129,63 +137,34 @@ function addUrlToGraph(url, parent) {
 function getFileMid(file) {
   const filename = basename(file)
   const ret = filename.split('.')
-  if (ret.length === 3)
-    return ret[1]
-  else return ''
+  if (!['js', 'mjs', 'cjs', 'ts', 'tsx', 'mts', 'cts'].includes(ret.pop()))
+    return ''
+  if (!ret[0])// .dockerfile
+    return ''
+
+  return ret[1]
 }
 
 export const resolve = async (specifier, context, nextResolve) => {
-  // virtual file
-  if (config.virtualFile[specifier]) {
-    return {
-      format: 'ts',
-      url: specifier,
-      shortCircuit: true,
-    }
-  }
-  // entrypoint
-  if (!context.parentURL) {
-    if (/^file:\/\/\//.test(specifier) && existsSync(fileURLToPath(specifier))) {
-      entryUrl = specifier
-
+  if (customResolve) {
+    const url = await customResolve(specifier, context)
+    if (url) {
       return {
-        format: EXTENSIONS.some(ext => specifier.endsWith(ext))
-          ? 'ts'
-          : undefined,
-        url: specifier,
+        format: 'ts',
+        url,
         shortCircuit: true,
       }
     }
-    else {
-      // won't resolve virtual file as entry in vite
-      return nextResolve(specifier)
-    }
-  }
-  // url import
-  // it seems useless
-  if (/^file:\/\/\//.test(specifier) && extname(specifier) === '.ts') {
-    const url = addUrlToGraph(specifier, context.parentURL.split('?')[0])
-    return {
-      format: 'ts',
-      url,
-      shortCircuit: true,
-    }
-  }
-
-  // hmr import
-  if (
-    context.parentURL.includes('/node_modules/phecda-server')
-    && isAbsolute(specifier)
-  ) {
-    specifier = relative(fileURLToPath(entryUrl), specifier)
-      .replace(/\.ts$/, '')
-      .slice(1)
-    context.parentURL = entryUrl
   }
 
-  // import/require from external library
-  if (context.parentURL.includes('/node_modules/'))
+  // entrypoint
+  if (!context.parentURL)
     return nextResolve(specifier)
+
+  // @todo skip resolve to improve performance
+  // if (context.parentURL.includes('/node_modules/') && specifier.includes('/node_modules/'))
+  //   return nextResolve(specifier)
+
   const { resolvedModule } = ts.resolveModuleName(
     specifier,
     fileURLToPath(context.parentURL),
@@ -194,7 +173,7 @@ export const resolve = async (specifier, context, nextResolve) => {
     moduleResolutionCache,
   )
 
-  // import between loacl projects
+  // import among files in local project
   if (
     resolvedModule
     && !resolvedModule.resolvedFileName.includes('/node_modules/')
@@ -230,23 +209,24 @@ export const resolve = async (specifier, context, nextResolve) => {
   const resolveRet = await nextResolve(specifier)
 
   // ts resolve fail in some cases
-  if (resolveRet.url && isAbsolute(resolveRet.url))
-    resolveRet.url = pathToFileURL(resolveRet.url).href
+  if (resolveRet.url && isAbsolute(resolveRet.url)) {
+    const [path, query] = resolveRet.url.split('?')
+    resolveRet.url = pathToFileURL(path).href + (query ? `?${query}` : '')
+  }
 
   return resolveRet
 }
 // @todo the first params may be url or path, need to distinguish
 
 export const load = async (url, context, nextLoad) => {
-  if (config.virtualFile[url]) {
-    return {
-      format: 'module',
-      source: config.virtualFile[url],
-      shortCircuit: true,
-    }
+  let mode
+  if (context.importAttributes.ps) {
+    mode = context.importAttributes.ps
+    delete context.importAttributes.ps
   }
 
   url = url.split('?')[0]
+
   if (
     !url.includes('/node_modules/')
     && url.startsWith('file://')
@@ -255,7 +235,7 @@ export const load = async (url, context, nextLoad) => {
   ) {
     watchFiles.add(url)
 
-    if (IS_DEV) {
+    if (IS_DEV && mode !== 'not-hmr') {
       if (isModuleFileUrl(url)) {
         port.postMessage(
           JSON.stringify({
@@ -289,6 +269,17 @@ export const load = async (url, context, nextLoad) => {
       )
     }
   }
+  // after hmr
+  if (customLoad) {
+    const source = await customLoad(url, context)
+    if (source) {
+      return {
+        format: 'module',
+        source,
+        shortCircuit: true,
+      }
+    }
+  }
   // resolveModuleName failed
   // I don't know why it failed
   if (!context.format && url.endsWith('.ts'))
@@ -299,10 +290,12 @@ export const load = async (url, context, nextLoad) => {
 
     const code
       = typeof source === 'string' ? source : Buffer.from(source).toString()
+
     const compiled = (await compile(code, url)).replace(/_ts_metadata\(\"design:paramtypes\"\,/g, '_ts_metadata("design:paramtypes",()=>')// handle cycle
 
     if (unimportRet) {
       const { injectImports } = unimportRet
+
       return {
         format: 'module',
         source: (

package/register/utils.mjs

@@ -1,5 +1,6 @@
 import { basename } from 'path'
 import { transform } from '@swc-node/core'
+import psExports from './export.mjs'
 const injectInlineSourceMap = ({ code, map }) => {
   if (map) {
     const base64Map = Buffer.from(map, 'utf8').toString('base64')
@@ -19,6 +20,32 @@ export async function compile(sourcecode, filename) {
     emitDecoratorMetadata: true,
     experimentalDecorators: true,
     esModuleInterop: false,
+    swc: {
+
+      jsc: {
+        parser: {
+          syntax: 'typescript',
+          importAttributes: true,
+          decorators: true,
+          tsx: false,
+          dynamicImport: true,
+          strictPropertyInitialization: false,
+        },
+        experimental: {
+          keepImportAssertions: true,
+        },
+        transform: {
+          legacyDecorator: true,
+          decoratorMetadata: true,
+        },
+        // parser: {
+        //   importAttributes: true
+        // },
+        // experimental: {
+        //   keepImportAssertions: true
+        // }
+      },
+    },
   })
 
   return injectInlineSourceMap({ code, map })
@@ -26,18 +53,21 @@ export async function compile(sourcecode, filename) {
 
 export async function genUnImportRet(opts) {
   try {
-    const psExports = Object.keys(await import('../dist/index.mjs'))
     const { createUnimport } = await import('unimport')
     return createUnimport({
       ...opts,
-      imports: psExports
-        .map((k) => {
-          return { name: k, from: 'phecda-server' }
-        })
-        .concat(opts.imports || []),
+
+      presets: [
+        {
+          from: 'phecda-server',
+          imports: psExports,
+        },
+      ]
+        .concat(opts.presets || []),
     })
   }
   catch (e) {
+    console.error(e)
     return false
   }
 }

package/assets/ps.json

@@ -1,24 +0,0 @@
-{
-  "$schema": "https://unpkg.com/phecda-server/assets/schema.json",
-  "resolve": [
-    {
-      "source": "controller",
-      "importer": "http",
-      "path": ".ps/http.js"
-    },
-    {
-      "source": "rpc",
-      "importer": "client",
-      "path": ".ps/rpc.js"
-    }
-  ],
-  "unimport": {
-    "dirs": ["."],
-    "dirsScanOptions": {
-      "filePatterns": ["*.{service,controller,module,rpc,solo,guard,extension,pipe,filter,addon}.ts"]
-    }
-  },
-  "virtualFile": {},
-  "moduleFile": []
-
-}

package/assets/tsconfig.json

@@ -1,21 +0,0 @@
-{
-    "compilerOptions": {
-      "target": "esnext",
-      "useDefineForClassFields": false,
-      "experimentalDecorators": true,
-      "emitDecoratorMetadata": true,
-      "module": "esnext",
-      "lib": ["esnext", "DOM"],
-      "strictPropertyInitialization": false,
-      "moduleResolution": "Node",
-      "strict": true,
-      "resolveJsonModule": true,
-      "esModuleInterop": true,
-      "noEmit": true,
-      "noUnusedLocals": true,
-      "noUnusedParameters": true,
-      "noImplicitReturns": true,
-      "skipLibCheck": true
-    },
-    "include": [".","./ps.d.ts"]
-  }

package/dist/types-B-rUM9Fm.d.mts

@@ -1,19 +0,0 @@
-import { D as DefaultOptions, B as BaseCtx } from './meta-BX5jhe4Z.mjs';
-
-interface RpcServerOptions extends DefaultOptions {
-    defaultQueue?: string;
-}
-interface RpcClientOptions {
-    key?: string;
-    timeout?: number;
-    max?: number;
-}
-interface RpcCtx extends BaseCtx {
-    args: any[];
-    id: string;
-    queue: string;
-    isEvent?: boolean;
-    category: 'rpc';
-}
-
-export type { RpcCtx as R, RpcServerOptions as a, RpcClientOptions as b };

package/dist/types-MxxtkZXw.d.ts

@@ -1,19 +0,0 @@
-import { D as DefaultOptions, B as BaseCtx } from './meta-BX5jhe4Z.js';
-
-interface RpcServerOptions extends DefaultOptions {
-    defaultQueue?: string;
-}
-interface RpcClientOptions {
-    key?: string;
-    timeout?: number;
-    max?: number;
-}
-interface RpcCtx extends BaseCtx {
-    args: any[];
-    id: string;
-    queue: string;
-    isEvent?: boolean;
-    category: 'rpc';
-}
-
-export type { RpcCtx as R, RpcServerOptions as a, RpcClientOptions as b };