@cloudbase/container 2.5.40-beta.0 → 2.5.41-beta.0

package/src/utils/index.ts

@@ -15,15 +15,36 @@ export function isBuffer(buf: any) {
   return buf instanceof ArrayBuffer || ArrayBuffer.isView(buf)
 }
 
-export function serializeRequestBody<T>(headers, data: T): T | string {
+function object2Qs(data) {
+  const list = Object.entries(data || {}).reduce((list, [key, value]: [string, string]) => {
+    list.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+    return list
+  }, [])
+  if (list.length) {
+    return list.join('&')
+  }
+}
+
+export function serializeRequestBody<T>(headers, data: T, method = 'POST'): T | string {
   let res: T | string = data
-  const contentType_key = 'Content-Type'
+  const contentTypeKey = 'Content-Type'
   if (typeof data === 'object' && !isBuffer(data)) {
-    if (!headers[contentType_key] && !headers['content-type']) {
-      headers[contentType_key] = 'application/json'
+    if (!headers[contentTypeKey] && !headers['content-type']) {
+      headers[contentTypeKey] = 'application/json'
     }
 
-    const contentType = headers[contentType_key] || headers['content-type']
+    const contentType = headers[contentTypeKey] || headers['content-type']
+
+    if (method === 'GET') {
+      try {
+        return object2Qs(data) || ''
+      } catch (e) {
+        throw new Error(JSON.stringify({
+          code: ERRORS.INVALID_PARAMS,
+          msg: `[${COMPONENT_NAME}.callContainer] invalid data in query method, ${e.message}`,
+        }),)
+      }
+    }
 
     switch (contentType) {
       case 'application/json': {
@@ -39,12 +60,9 @@ export function serializeRequestBody<T>(headers, data: T): T | string {
       }
       case 'application/x-www-form-urlencoded': {
         try {
-          const list = Object.entries(data || {}).reduce((list, [key, value]: [string, string]) => {
-            list.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-            return list
-          }, [])
-          if (list.length) {
-            res = list.join('&')
+          const qs = object2Qs(data)
+          if (qs) {
+            res = qs
           }
         } catch (e) {
           throw new Error(JSON.stringify({

package/src/utils/loader.ts

@@ -0,0 +1,139 @@
+// import decompress from 'brotli/decompress'
+import Go from '../go_wams_exec'
+import { parseURL } from '.'
+
+async function instantiateStreaming(resp, importObject, brotliCompressed = false) {
+  if (brotliCompressed || !WebAssembly.instantiateStreaming) {
+    const source = await (await resp).arrayBuffer()
+    if (brotliCompressed) {
+      throw new Error('do not support *.br')
+    }
+    // const buffer = brotliCompressed ? decompress(new Int8Array(source)) : source
+    const buffer = source
+    return WebAssembly.instantiate(buffer, importObject)
+  }
+
+  return WebAssembly.instantiateStreaming(resp, importObject)
+}
+
+function isBrotliCompressed(url) {
+  let brotliCompressed = false
+
+  let pathname = ''
+  try {
+    const location = parseURL(url)
+    pathname = location.pathname
+  } catch (e) {
+    pathname = url
+  }
+
+  if (/\.br$/.test(pathname)) {
+    brotliCompressed = true
+  }
+  return brotliCompressed
+}
+
+export async function getExportFunction(url, module, mode = 'go') {
+  let importObject = {
+    env: {
+      memoryBase: 0,
+      tableBase: 0,
+      memory: new WebAssembly.Memory({
+        initial: 256,
+      }),
+      // table: new WebAssembly.Table({
+      //   initial: 2,
+      //   element: 'anyfunc',
+      // }),
+    },
+    ...module,
+  }
+  let go
+  const brotliCompressed = isBrotliCompressed(url)
+
+  if (mode === 'go') {
+    go = new Go()
+    go._initedModulePromise = new Promise((resolve) => {
+      go._initedModuleResolve = resolve
+    })
+    importObject = {
+      ...go.importObject,
+      env: {
+        ...go.importObject.env,
+        exportModule(module) {
+          return go._initedModuleResolve(module)
+        },
+      },
+    }
+  }
+
+  const reuslt = await instantiateStreaming(fetch(url), importObject, brotliCompressed)
+
+  if (mode === 'go') {
+    await Promise.race([
+      go.run(reuslt.instance),
+      new Promise(resolve => setTimeout(() => {
+        resolve(null)
+      }, 500),),
+    ])
+
+    return {
+      callContainer: (window as any).callContainer,
+      initContainer: (window as any).initContainer,
+    }
+  }
+
+  // if (mode === 'go') {
+  //   go.run(reuslt.instance)
+  //   const module = await go._initedModulePromise
+  //   return module
+  // }
+
+  return reuslt.instance.exports
+}
+
+export async function loadJSExportFunction(config?: { vm: string; vender?: string }) {
+  const { vm, vender } = config || {}
+  const VENDER_KEY = 'cloudbase_private_link_vender'
+
+  if (vender || !Object.prototype.hasOwnProperty.call(document.defaultView, VENDER_KEY)) {
+    await loadUmdModule(
+      vender
+        || 'https://qbase.cdn-go.cn/lcap/lcap-resource-cdngo/-/release/_npm/@cloudbase/privatelink-vender@0.0.2/dist/cdn/cloudbase.privatelink.vender.js',
+      VENDER_KEY,
+    )
+  }
+
+  return loadUmdModule(
+    vm
+      || 'https://qbase.cdn-go.cn/lcap/lcap-resource-cdngo/-/release/_npm/@cloudbase/privatelink@0.0.1/dist/cdn/cloudbase.privatelink.vm.js',
+    'cloudbase_private_link',
+  )
+}
+
+function loadUmdModule(jsUrl: string, umdModuleName: string, targetDoc: Document = document) {
+  return new Promise<any>((resolve, reject) => {
+    const win = targetDoc.defaultView
+
+    const script = targetDoc.createElement('script')
+    script.setAttribute('src', jsUrl)
+    script.setAttribute('class', umdModuleName)
+    script.addEventListener('load', () => {
+      if (Object.prototype.hasOwnProperty.call(win, umdModuleName)) {
+        return resolve(win[umdModuleName as any])
+      }
+      const error = new Error(`Fail to load UMD module ${umdModuleName} from [${jsUrl}].`)
+      return reject(error)
+    })
+
+    script.addEventListener('error', (e) => {
+      const error = new Error(`main bundle [${umdModuleName}] load failed from [${jsUrl}]: ${e?.message || ''}`)
+      reject(error)
+    })
+    if (targetDoc.body) {
+      targetDoc.body.appendChild(script)
+    } else {
+      targetDoc.head.appendChild(script)
+    }
+  })
+}

package/webpack/web.prod.js

@@ -0,0 +1,84 @@
+const webpack = require('webpack')
+const TerserPlugin = require('terser-webpack-plugin')
+const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin
+
+module.exports = function (options) {
+  const { context, entry, output, mode, watch, externals, definePlugin = {}, optimization = {} } = options
+  const isDevelopment = mode !== 'production'
+  let plugins = [
+    // new WatchRunPlugin()
+    new webpack.DefinePlugin(
+      Object.assign(
+        {
+          'globalThis.IS_MP_BUILD': false,
+        },
+        definePlugin,
+      ),
+    ),
+    // new BundleAnalyzerPlugin(),
+  ].filter((item) => !!item)
+  return {
+    context,
+    entry,
+    mode,
+    watch,
+    watchOptions: {
+      ignored: [output.path],
+    },
+    output,
+    externals,
+    cache: {
+      type: 'memory',
+    },
+    devtool: false,
+    resolve: {
+      extensions: ['.ts', '.js', '.json'],
+    },
+    module: {
+      rules: [
+        {
+          test: /\.ts$/,
+          exclude: [/node_modules/],
+          use: ['babel-loader', 'ts-loader'],
+        },
+        {
+          test: /\.js$/,
+          exclude: [/node_modules/],
+          use: ['babel-loader'],
+        },
+        {
+          test: /package\.json$/,
+          loader: 'package-json-cleanup-loader',
+          options: {
+            only: ['version'],
+          },
+        },
+      ],
+      noParse: [/sjcl\.js$/],
+    },
+    plugins,
+    optimization: {
+      moduleIds: 'deterministic',
+      emitOnErrors: false,
+      removeEmptyChunks: true,
+      usedExports: true,
+      splitChunks: false,
+      ...optimization,
+      ...(isDevelopment
+        ? {
+            minimize: false,
+            removeAvailableModules: false,
+            concatenateModules: true,
+          }
+        : {
+            minimizer: [
+              new TerserPlugin({
+                test: /\.js(\?.*)?$/i,
+                cache: false,
+                parallel: true,
+              }),
+            ],
+          }),
+    },
+  }
+}

package/webpack/webpack.miniprogram.js

@@ -0,0 +1,22 @@
+const path = require('path')
+
+const params = {
+  context: path.resolve(__dirname, '../../'),
+  mode: 'production',
+  watch: false,
+  entry: path.resolve(__dirname, '../src/index.ts'),
+  output: {
+    path: path.resolve(__dirname, '../dist/miniprogram'),
+    filename: 'index.js',
+    library: `cloudbase_container`,
+    libraryTarget: 'umd',
+    umdNamedDefine: true,
+    globalObject: 'typeof window !== "undefined"?window:this',
+  },
+  externals: {},
+  definePlugin: {
+    'globalThis.IS_MP_BUILD': true, // 注入环境变量，用于业务代码判断
+  },
+}
+
+module.exports = require('./web.prod.js')(params)