@cloudbase/container 2.5.29-beta.0

package/src/index.ts

@@ -0,0 +1,330 @@
+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'
+
+declare const cloudbase: ICloudbase
+
+const { getSdkName, ERRORS, COMMUNITY_SITE_URL } = constants
+const { execCallback, printWarn } = utils
+const { catchErrorsDecorator } = helpers
+
+const COMPONENT_NAME = 'container'
+
+/**
+ * 封装对齐 wx.request
+ */
+async function request({
+  url,
+  method = 'GET',
+  header = {},
+  data,
+  timeout = 60000,
+  dataType = 'json',
+  responseType = 'text',
+}: {
+  url: string
+  data?: string | object | ArrayBuffer
+  header?: Record<string, string>
+  timeout?: number
+  method?: string
+  dataType?: 'json' | string
+  responseType?: 'text' | 'arrayBuffer'
+}) {
+  const headers = { ...header }
+
+  if (typeof data === 'object' && !(data instanceof ArrayBuffer || ArrayBuffer.isView(data))) {
+    if (!headers['Content-Type'] && !headers['content-type']) {
+      headers['Content-Type'] = 'application/json'
+    }
+    try {
+      data = JSON.stringify(data)
+    } catch (e) {
+      throw new Error(JSON.stringify({
+        code: ERRORS.INVALID_PARAMS,
+        msg: `[${COMPONENT_NAME}.callContainer] invalid data with content-type: application/json`,
+      }),)
+    }
+  }
+
+  const { signal, abort } = new AbortController()
+
+  return Promise.race([
+    new Promise((_, reject) => {
+      setTimeout(() => {
+        const error = new Error('请求超时')
+        ;(error as any).code = 'SERVER_TIMEOUT'
+        reject(error)
+        abort()
+      }, timeout)
+    }),
+    fetch(url, {
+      method,
+      headers,
+      body: data,
+      signal,
+    }).then((response) => {
+      if (responseType === 'arrayBuffer') {
+        return response.arrayBuffer()
+      }
+      if (dataType === 'json') {
+        try {
+          return response.json()
+        } catch (e) {
+          throw new Error(`[${getSdkName()}][${ERRORS.INVALID_PARAMS}][${COMPONENT_NAME}.callContainer] response data must be json`,)
+        }
+      }
+      return response.text()
+    }),
+  ])
+}
+
+class InvalieParamsError extends Error {
+  constructor(scope, message) {
+    const msg = JSON.stringify({
+      code: ERRORS.INVALID_PARAMS,
+      msg: `[${scope}] ${message}`,
+    })
+    super(msg)
+  }
+}
+
+interface ICallTcbContainerOptions extends ICallContainerOptions {
+  success: (res: { statusCode: string | number; header: ICallContainerOptions['header']; data: any }) => void
+  fail: (res: { data: { code: number; message: string } }) => void
+}
+
+interface IInitTcbContainerOptions {
+  config: Omit<IContianerConfig, 'wasmUrl'>
+  success: (res: { statusCode: string | number; header: ICallContainerOptions['header']; data: any }) => void
+  fail: (res: { data: { code: number; message: string } }) => void
+}
+
+class CloudbaseContainers {
+  private readonly config: IContianerConfig
+  private wasm: Promise<WebAssembly.Exports>
+  private containerInitPromise: /* Promise<any>*/ any | null
+
+  constructor(config: IContianerConfig) {
+    this.config = config
+    if (!this.config.wasmUrl) {
+      throw new Error(JSON.stringify({
+        code: ERRORS.INVALID_PARAMS,
+        msg: `[${COMPONENT_NAME}] 缺少 wasmUrl`,
+      }),)
+    }
+    this.wasm = getExportFunction(this.config.wasmUrl, {
+      utils: {
+        info(e) {
+          console.log(e)
+        },
+        request,
+      },
+    })
+  }
+
+  @catchErrorsDecorator({
+    customInfo: {
+      className: 'Cloudbase',
+      methodName: 'callContainer',
+    },
+    title: '调用失败',
+    messages: [
+      '请确认以下各项：',
+      '  1 - 调用 callContainer() 的语法或参数是否正确',
+      '  2 - 域名 & 路径是否存在',
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
+  })
+  public async callContainer(options: ICallContainerOptions, callback?: Function) {
+    await this.initContainer(this.config)
+    const { callContainer }: { callContainer: (options: ICallTcbContainerOptions) => void } = (await this.wasm) as any
+
+    const {
+      url,
+      method = 'GET',
+      header = {},
+      data,
+      timeout = 60000,
+      dataType = 'json',
+      responseType = 'text',
+      ...restOptions
+    } = options
+
+    if (!url) {
+      throw new InvalieParamsError(`${COMPONENT_NAME}.callContainer`, 'invalid request url')
+    }
+
+    // @ts-ignore
+
+    try {
+      const res = await new Promise((resolve, reject) => {
+        const params = { url, method, header, data, timeout, dataType, responseType, ...restOptions }
+
+        callContainer({
+          ...params,
+          success: resolve,
+          fail: (res) => {
+            const { data } = res || {}
+            const error = new Error(data?.message || 'call container error')
+            ;(error as any).code = data?.code || 'UNKNOWN_ERROR'
+            reject(error)
+          },
+        })
+      })
+      return execCallback(callback, null, res)
+    } catch (e) {
+      execCallback(callback, e)
+    }
+  }
+
+  async initContainer(config: Omit<IContianerConfig, 'wasmUrl'>) {
+    const { initContainer }: { initContainer: (options: IInitTcbContainerOptions) => void } = (await this.wasm) as any
+    if (!this.containerInitPromise) {
+      this.containerInitPromise = new Promise((resolve, reject) => {
+        initContainer({
+          config,
+          success(res) {
+            if (String(res.statusCode) !== '200') {
+              reject(new Error(JSON.stringify({
+                code: 'INIT_ERROR',
+                msg: `[${COMPONENT_NAME}] ${res.statusCode} ${JSON.stringify(res.data)}`,
+              }),),)
+            }
+            resolve(res)
+          },
+          fail(res) {
+            reject(new Error(JSON.stringify({
+              code: 'INIT_ERROR',
+              msg: `[${COMPONENT_NAME}] ${JSON.stringify(res.data)}`,
+            }),),)
+            this._containerInitPromis = null
+          },
+        })
+      })
+    }
+
+    return this.containerInitPromise
+  }
+}
+
+const component: ICloudbaseComponent = {
+  name: COMPONENT_NAME,
+  namespace: 'container',
+  entity(config: IContianerConfig) {
+    if (this.containerInstance) {
+      printWarn(ERRORS.INVALID_OPERATION, 'every cloudbase instance should has only one container object')
+      return this.containerInstance
+    }
+
+    const instance = new CloudbaseContainers(config)
+    this.containerInstance = instance
+    this.callContainer = instance.callContainer.bind(instance)
+
+    return this.containerInstance
+  },
+}
+try {
+  cloudbase.registerComponent(component)
+} catch (e) {}
+
+export function registerContainers(app: Pick<ICloudbase, 'registerComponent'>) {
+  try {
+    app.registerComponent(component)
+  } catch (e) {
+    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 isBrotliCompressed(url) {
+  let brotliCompressed = false
+
+  let pathname = ''
+  try {
+    const a = document.createElement('a')
+    a.href = url
+    pathname = a.pathname
+  } catch (e) {
+    try {
+      const res = new URL(url)
+      pathname = res?.pathname
+    } catch (e) {
+      pathname = url
+    }
+  }
+
+  if (/\.br$/.test(pathname)) {
+    brotliCompressed = true
+  }
+  return brotliCompressed
+}

package/tsconfig.esm.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "es6",
+    "outDir": "dist/esm",
+    "rootDir": "src",
+  },
+  "include": [
+    "src/**/*.ts",
+    "package.json"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "dist/cjs",
+    "rootDir": "src",
+  },
+  "include": [
+    "src/**/*.ts",
+    "package.json"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}