phecda-server 8.0.2 → 8.2.0

package/register/index.mjs

@@ -2,6 +2,7 @@ import { register } from 'node:module'
 import { MessageChannel } from 'node:worker_threads'
 import { isPhecda, log } from '../dist/index.mjs'
 import { RELAUNCH, RELOAD } from '../dist/helper.mjs'
+import inspector from 'inspector'
 const { port1, port2 } = new MessageChannel()
 
 register('./loader.mjs', {
@@ -47,3 +48,29 @@ process.on('unhandledRejection', (err) => {
 
   console.error(err)
 })
+
+
+process.on('message', (data) => {
+  if (data.type === 'inspect') {
+    if (inspector.url()) {
+      inspector.close();
+      log('close inspector', 'info');
+    } else {
+      const { arg } = data
+
+      if (arg) {
+        if (arg.includes(':')) {
+          const [host, port] = arg.split(':')
+          inspector.open(Number(port), host)
+        } else {
+          inspector.open(Number(arg))
+        }
+      }else {
+        inspector.open();
+      }
+      //  address already in use
+      if (inspector.url())
+        log(`open "devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=${inspector.url().replace("ws://", '')}" in browser`, 'info');
+    }
+  }
+})

package/register/loader.mjs

@@ -35,7 +35,7 @@ const dtsPath = process.env.PS_DTS_PATH || 'ps.d.ts'
 const watchFiles = new Set()
 const filesRecord = new Map()
 const moduleGraph = {}
-    // ts
+// ts
 let tsconfig = {
     module: ts.ModuleKind.ESNext,
     moduleResolution: ts.ModuleResolutionKind.NodeNext,
@@ -81,7 +81,7 @@ export async function initialize(data) {
 
     if (loaderPath) {
         const loader = await
-        import (loaderPath.startsWith('.') ? resolvePath(workdir, loaderPath) : loaderPath)
+            import(loaderPath.startsWith('.') ? resolvePath(workdir, loaderPath) : loaderPath)
 
         if (typeof loader.load === 'function')
             customLoad = loader.load
@@ -147,80 +147,80 @@ function getFileMid(file) {
     return ret[1]
 }
 
-export const resolve = async(specifier, context, nextResolve) => {
-        if (customResolve) {
-            const url = await customResolve(specifier, context)
-            if (url) {
-                return {
-                    format: 'ts',
-                    url,
-                    shortCircuit: true,
-                }
+export const resolve = async (specifier, context, nextResolve) => {
+    if (customResolve) {
+        const url = await customResolve(specifier, context)
+        if (url) {
+            return {
+                format: 'ts',
+                url,
+                shortCircuit: true,
             }
         }
+    }
 
-        // entrypoint
-        if (!context.parentURL)
-            return nextResolve(specifier)
+    // 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)
+    // @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),
-            tsconfig,
-            host,
-            moduleResolutionCache,
+    const { resolvedModule } = ts.resolveModuleName(
+        specifier,
+        fileURLToPath(context.parentURL),
+        tsconfig,
+        host,
+        moduleResolutionCache,
+    )
+
+    // import among files in local project
+    if (
+        resolvedModule &&
+        !resolvedModule.resolvedFileName.includes('/node_modules/') &&
+        EXTENSIONS.includes(resolvedModule.extension)
+    ) {
+        const url = addUrlToGraph(
+            pathToFileURL(resolvedModule.resolvedFileName).href,
+            context.parentURL.split('?')[0],
         )
 
-        // import among files in local project
-        if (
-            resolvedModule &&
-            !resolvedModule.resolvedFileName.includes('/node_modules/') &&
-            EXTENSIONS.includes(resolvedModule.extension)
-        ) {
-            const url = addUrlToGraph(
-                pathToFileURL(resolvedModule.resolvedFileName).href,
-                context.parentURL.split('?')[0],
+        const importerMid = getFileMid(context.parentURL)
+        const sourceMid = getFileMid(resolvedModule.resolvedFileName)
+        if (config.resolve && importerMid && sourceMid) {
+            const resolver = config.resolve.find(
+                item => item.source === sourceMid && item.importer === importerMid,
             )
-
-            const importerMid = getFileMid(context.parentURL)
-            const sourceMid = getFileMid(resolvedModule.resolvedFileName)
-            if (config.resolve && importerMid && sourceMid) {
-                const resolver = config.resolve.find(
-                    item => item.source === sourceMid && item.importer === importerMid,
-                )
-                if (resolver) {
-                    return {
-                        format: 'ts',
-                        url: pathToFileURL(resolvePath(workdir, resolver.path)).href,
-                        shortCircuit: true,
-                    }
+            if (resolver) {
+                return {
+                    format: 'ts',
+                    url: pathToFileURL(resolvePath(workdir, resolver.path)).href,
+                    shortCircuit: true,
                 }
             }
-
-            return {
-                format: 'ts',
-                url,
-                shortCircuit: true,
-            }
         }
 
-        const resolveRet = await nextResolve(specifier)
-
-        // ts resolve fail in some cases
-        if (resolveRet.url && isAbsolute(resolveRet.url)) {
-            const [path, query] = resolveRet.url.split('?')
-            resolveRet.url = pathToFileURL(path).href + (query ? `?${query}` : '')
+        return {
+            format: 'ts',
+            url,
+            shortCircuit: true,
         }
+    }
+
+    const resolveRet = await nextResolve(specifier)
 
-        return resolveRet
+    // ts resolve fail in some cases
+    if (resolveRet.url && isAbsolute(resolveRet.url)) {
+        const [path, query] = resolveRet.url.split('?')
+        resolveRet.url = pathToFileURL(path).href + (query ? `?${query}` : '')
     }
-    // @todo the first params may be url or path, need to distinguish
 
-export const load = async(url, context, nextLoad) => {
+    return resolveRet
+}
+// @todo the first params may be url or path, need to distinguish
+
+export const load = async (url, context, nextLoad) => {
     let mode
     if (context.importAttributes.ps) {
         mode = context.importAttributes.ps
@@ -281,13 +281,13 @@ export const load = async(url, context, nextLoad) => {
         }
     }
 
- 
+
     // resolveModuleName failed
     // I don't know why it failed
-    if ( url.endsWith('.ts'))
+    if (url.endsWith('.ts'))
         context.format = 'ts'
 
-     // module-typescript???
+    // module-typescript???
 
     if (context.format === 'ts') {
         const { source } = await nextLoad(url, context)
@@ -298,7 +298,7 @@ export const load = async(url, context, nextLoad) => {
      
         if (unimportRet) {
             const { injectImports } = unimportRet
-
+      
             return {
                 format: 'module',
                 source: (
@@ -327,7 +327,7 @@ function findTopScope(url, time, modules = new Set()) {
     } else {
         if (!moduleGraph[url])
             throw new Error('root file update')
-        for (const i of[...moduleGraph[url]]) findTopScope(i, time, modules)
+        for (const i of [...moduleGraph[url]]) findTopScope(i, time, modules)
     }
 
     return modules

package/register/utils.mjs

@@ -1,6 +1,8 @@
 import { basename } from 'path'
 import { transform } from '@swc-node/core'
-import psExports from './export.mjs'
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+
 const injectInlineSourceMap = ({ code, map }) => {
     if (map) {
         const base64Map = Buffer.from(map, 'utf8').toString('base64')
@@ -10,35 +12,28 @@ const injectInlineSourceMap = ({ code, map }) => {
     return code
 }
 
-export async function compile(sourcecode, filename, config = {}) {
-    if (filename.endsWith('.d.ts'))
+export async function compile(sourcecode, url, config = {}) {
+    if (url.endsWith('.d.ts'))
         return ''
 
+    const filename = path.basename(url.startsWith('file:') ? fileURLToPath(url) : url)
+
     const { code, map } = await transform(sourcecode, filename, {
-        sourcemap: true,
         module: 'es6',
         emitDecoratorMetadata: true,
         experimentalDecorators: true,
         esModuleInterop: false,
+        sourcemap:false,
         ...config
     })
-
     return injectInlineSourceMap({ code, map })
 }
 
 export async function genUnImportRet(opts) {
     try {
         const { createUnimport } = await
-        import ('unimport')
-        return createUnimport({
-            ...opts,
-
-            presets: [{
-                    from: 'phecda-server',
-                    imports: psExports,
-                }, ]
-                .concat(opts.presets || []),
-        })
+            import('unimport')
+        return createUnimport(opts)
     } catch (e) {
         return false
     }

package/register/export.mjs

@@ -1,39 +0,0 @@
-export default ['Addon', 'Arg', 'Assign', 'BadGatewayException', 'BadRequestException',
-  'Base', 'Body', 'Clear',
-  'ConflictException', 'Controller',
-  'Ctx', 'CustomResponse',
-  'Delete',
-  'Define',
-  'ERROR_SYMBOL',
-  'Effect', 'Empty', 'Err', 'Exception', 'Expose', 'Factory', 'Filter', 'ForbiddenException',
-  'FrameworkException',
-  'Generator', 'Get', 'Global', 'Guard', 'HTTPGenerator', 'Head', 'Header', 'HttpBase',
-  'If', 'Init', 'Inject', 'Injectable',
-  'InvalidInputException', 'Isolate',
-  'Mixin',
-  'NotFoundException', 'PAddon', 'PExtension', 'PFilter', 'PGuard',
-  'PPipe', 'Param', 'Patch', 'PayloadLargeException', 'Pipe', 'Pipeline', 'Post',
-  'Provide', 'Put', 'Query', 'Queue', 'RPCGenerator', 'Route',
-  'Rpc', 'RpcBase', 'Search', 'ServerBase', 'ServerPhecda', 'ServiceUnavailableException', 'Storage',
-  'Tag', 'TimeoutException', 'TimerException', 'UnauthorizedException', 'UndefinedException',
-  'Unique', 'Unmount', 'UnsupportedMediaTypeException', 'ValidateException',
-  'Watcher', 'WorkerException',
-  'addAddon', 'addDecoToClass',
-  'addFilter', 'addGuard', 'addPipe', 'emitter',
-  'getMergedMeta','getMeta', 'getMetaKey', 'getMetaParams', 'getOwnMeta', 'getOwnMetaKey', 'getOwnMetaParams',
-  'getTag',
-  'isPhecda', 'log', 'phecdaNamespace', 'runMiddleware',
-  'setInject',
-  'setLogger',
-  'setMeta',
-  'useS', 'wait', 'OneFile', 'ManyFiles',
-  'Rule','Required','Optional',
-  'validate',
-  'Min','Max','Enum','OneOf','Nested',
-  
-  'Doc','DocGenerator',
-  'pick','omit','partial',
-  'functionToClass','objectToClass'
-
-
-]