@cloudbase/container 2.5.36-beta.0 → 2.5.37-alpha.2

package/src/index.ts

@@ -2,20 +2,36 @@ import { ICloudbase } from '@cloudbase/types'
 import { ICloudbaseComponent } from '@cloudbase/types/component'
 import { ICallContainerOptions, IContianerConfig } from '@cloudbase/types/container'
 import { constants, utils, helpers } from '@cloudbase/utilities'
-// import brotliPromise from 'brotli-dec-wasm' // Import the default export
-import decompress from 'brotli/decompress'
-
-import Go from './go_wams_exec'
 import { isBuffer, parseURL, serializeRequestBody } from './utils'
-import { request } from './utils/request'
 import { COMPONENT_NAME } from './constants'
 
 declare const cloudbase: ICloudbase
-
 const { ERRORS, COMMUNITY_SITE_URL } = constants
 const { execCallback, printWarn } = utils
 const { catchErrorsDecorator } = helpers
 
+/* eslint-disable */
+let getExportFunction: Function = () => {
+  throw new Error('getExportFunction 未实现')
+}
+let loadJSExportFunction: Function = () => {
+  throw new Error('loadJSExportFunction 未实现')
+}
+
+if (globalThis.IS_MP_BUILD) {
+  getExportFunction = function () {
+    new Error('小程序不支持 wasm 加载')
+  }
+  loadJSExportFunction = function () {
+    new Error('小程序不支持动态 js 加载')
+  }
+} else {
+  const loader = require('./utils/loader')
+  getExportFunction = loader.getExportFunction
+  loadJSExportFunction = loader.loadJSExportFunction
+}
+/* eslint-enable */
+
 class InvalieParamsError extends Error {
   code: any
   constructor(scope, message) {
@@ -51,43 +67,45 @@ function genContainerError(data, scope = COMPONENT_NAME, defaultMessage = 'call
   return error
 }
 
-class CloudbaseContainers {
-  private readonly config: IContianerConfig
+export class CloudbaseContainers {
+  private readonly config: IContianerConfig & { jsUrl?: { vender?: string; vm: string } }
   private wasm: Promise<WebAssembly.Exports>
   private containerInitPromise: /* Promise<any>*/ any | null
 
   constructor(config: IContianerConfig) {
     this.config = {
       ...config,
+      jsUrl:
+        typeof config.jsUrl === 'string'
+          ? {
+            vm: config.jsUrl,
+          }
+          : (config.jsUrl as any),
     }
 
-    if (!this.config.wasmUrl && !this.config.jsUrl && !(window as any).cloudbase_private_link) {
+    if (!this.config.wasmUrl && this.config.publicKey) {
+      // 非 wams 且有 public key 则可使用默认的 js-sdk，无需校验
+    } else if (!this.config.wasmUrl && !this.config.jsUrl?.vm && !(globalThis as any).cloudbase_private_link) {
       throw new InvalieParamsError(`${COMPONENT_NAME}`, '缺少 privatelink sdk 地址')
     }
 
     if (this.config.wasmUrl) {
-      this.wasm = getExportFunction(this.config.wasmUrl, {
-        utils: {
-          info(e) {
-            console.log(e)
-          },
-          request,
-        },
-      }).catch((e) => {
+      this.wasm = getExportFunction(this.config.wasmUrl).catch((e) => {
         if (this.config.jsUrl) {
           console.warn('load wams error, fall back to use js', e)
           return loadJSExportFunction(this.config.jsUrl)
-        } if ((window as any).cloudbase_private_link) {
-          return (window as any).cloudbase_private_link
+        }
+        if ((globalThis as any).cloudbase_private_link) {
+          return (globalThis as any).cloudbase_private_link
         }
         throw e
       })
-    } else if (this.config.jsUrl) {
+    } else if (this.config.jsUrl || this.config.publicKey) {
       this.wasm = loadJSExportFunction(this.config.jsUrl)
     } else {
       this.wasm = Promise.resolve({
-        initContainer: (window as any).cloudbase_private_link.initContainer,
-        callContainer: (window as any).cloudbase_private_link.callContainer,
+        initContainer: (globalThis as any).cloudbase_private_link.initContainer,
+        callContainer: (globalThis as any).cloudbase_private_link.callContainer,
       })
     }
   }
@@ -138,36 +156,44 @@ class CloudbaseContainers {
           url,
           method,
           header,
-          data: serializeRequestBody(header, data),
+          data: serializeRequestBody(header, data, method),
           timeout,
           dataType,
           responseType,
           ...restOptions,
         }
 
-        /**
-         * 非 buffer
-         */
-        if (params.data !== undefined && !isBuffer(params.data)) {
-          if (typeof params.data !== 'string' && method === 'GET') {
-            try {
-              const list = Object.entries(params.data || {}).reduce(
-                (list, [key, value]: [string, string | number | boolean]) => {
-                  list.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
-                  return list
-                },
-                [],
-              )
-              if (list.length) {
-                params.data = list.join('&')
-              }
-            } catch (e) {}
+        if (
+          data
+          && (isBuffer(params.data) || typeof params.data === 'string')
+          && (data as any)?.length > 1000 * 1024 * 10
+        ) {
+          reject(new InvalieParamsError(SCOPE, 'body too large'))
+          return
+        }
+
+        if (method === 'GET') {
+          let { data: getBody } = params
+          if (getBody) {
+            params.data = undefined
+          }
+          if (!isBuffer(getBody) && typeof getBody !== 'string') {
+            const list = Object.entries(getBody || {}).reduce(
+              (list, [key, value]: [string, string | number | boolean]) => {
+                list.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
+                return list
+              },
+              [],
+            )
+            if (list.length) {
+              getBody = list.join('&')
+            }
           }
 
-          if (method === 'GET' && typeof params.data === 'string') {
+          if (typeof params.data === 'string') {
             const parsedUrl = parseURL(url)
             if (parsedUrl.search) {
-              parsedUrl.search += params.data
+              parsedUrl.search += `&${params.data}`
             } else {
               parsedUrl.search = `?${params.data}`
             }
@@ -176,15 +202,6 @@ class CloudbaseContainers {
           }
         }
 
-        if (
-          data
-          && (isBuffer(params.data) || typeof params.data === 'string')
-          && (data as any)?.length > 1000 * 1024 * 10
-        ) {
-          reject(new InvalieParamsError(SCOPE, 'body too large'))
-          return
-        }
-
         callContainer({
           ...params,
           success: resolve,
@@ -206,15 +223,15 @@ class CloudbaseContainers {
       this.containerInitPromise = new Promise((resolve, reject) => {
         initContainer({
           config,
-          success(res) {
+          success: (res) => {
             if (String(res.statusCode) !== '200') {
               reject(genContainerError(res.data, `${COMPONENT_NAME}.initContainer`, 'init container fail'))
             }
             resolve(res)
           },
-          fail(res) {
+          fail: (res) => {
             reject(genContainerError(res.data, `${COMPONENT_NAME}.initContainer`, 'init container fail'))
-            this._containerInitPromis = null
+            this.containerInitPromise = null
           },
         })
       })
@@ -251,116 +268,3 @@ export function registerContainers(app: Pick<ICloudbase, 'registerComponent'>) {
     console.warn(e)
   }
 }
-
-async function getExportFunction(url, module, mode = 'go') {
-  async function instantiateStreaming(resp, importObject, brotliCompressed = false) {
-    if (brotliCompressed || !WebAssembly.instantiateStreaming) {
-      const source = await (await resp).arrayBuffer()
-      const buffer = brotliCompressed ? decompress(new Int8Array(source)) : source
-      return WebAssembly.instantiate(buffer, importObject)
-    }
-
-    return WebAssembly.instantiateStreaming(resp, importObject)
-  }
-
-  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
-}
-
-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)
-    })
-    targetDoc.body.appendChild(script)
-  })
-}
-
-async function loadJSExportFunction(url) {
-  return loadUmdModule(url, 'cloudbase_private_link')
-}
-
-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
-}

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,134 @@
+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()
+    const buffer = brotliCompressed ? decompress(new Int8Array(source)) : 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://cdn.jsdelivr.net/npm/@cloudbase/privatelink-vender@0.0.1-alpha.3/dist/cdn/cloudbase.privatelink.vender.js',
+      VENDER_KEY,
+    )
+  }
+
+  return loadUmdModule(
+    vm || 'https://cdn.jsdelivr.net/npm/@cloudbase/privatelink@0.0.1-alpha.0/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)