usf-cli 1.1.3

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/usf-cli.iml" filepath="$PROJECT_DIR$/.idea/usf-cli.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/usf-cli.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/LICENSE.md

@@ -0,0 +1,6 @@
+usf-cli copyright © 2023 Unity Technologies
+
+Your use of the Unity Technologies ("Unity") services known as "usf-cli" are subject to the UOS Terms of Service linked to and copied immediately below.
+[Unity Online Services TOS](https://uos.unity.cn/policy/tos)
+
+Your use of the usf-cli constitutes your acceptance of such terms. Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.

package/README.md

@@ -0,0 +1,50 @@
+# Develop UOS Func Stateless with usf-cli
+
+## Install usf-cli
+```bash
+npm install -g git+https://e.coding.net/unitychina/uos/usf-cli.git
+```
+
+## Create project
+```bash
+mkdir stateless-function
+cd stateless-function
+```
+
+## Init project
+```bash
+usf-cli -i
+# or
+npm init
+```
+
+## Creat function
+```bash
+# create default function
+usf-cli -c --f=helloWorld
+# or create function with crud template
+usf-cli -c --f=helloCrud --t=crud_mysql
+```
+
+## Edit function & event data
+```bash
+vim ./helloWorld/index.js
+# or open it in IDE
+```
+```bash
+vim ./.uos_test/helloWorld_event.json
+# or open it in IDE
+```
+
+## Install Dependency (If necessary)
+```bash
+npm install .
+```
+
+## Run function locally
+```bash
+# with default event data json(./uos_test/helloWorld_event.json)
+usf-cli -r --f=helloWorld
+# or with specified event data json(e.g. you have created a test.json in your project dir)
+usf-cli -r --f=helloWorld --e=./test.json
+```

package/index.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import minimist from "minimist";
+import { dynamicRunner } from "./utils/dynamic-runner/index.js";
+import { create, loader } from "./utils/function-construct/index.js";
+import { createRequire } from "module";
+import { spawn } from "child_process";
+import path from "path";
+import {
+  recordAuthInfoToFile,
+  getAuthInfoFromFile,
+  deployFunctionsToPlatform,
+} from "./utils/uploader/index.js";
+
+const parseArguments = () => {
+  const args = minimist(process.argv, {
+    string: [
+      "dir",
+      "function",
+      "f",
+      "event",
+      "e",
+      "template",
+      "t",
+      "id",
+      "secret",
+    ],
+    boolean: [
+      "v",
+      "version",
+      "h",
+      "help",
+      "i",
+      "init",
+      "c",
+      "create",
+      "run",
+      "r",
+      "a",
+      "auth",
+      "d",
+      "deploy",
+      "installDependency",
+    ],
+  });
+  return {
+    init: args.i || args.init,
+    version: args.v || args.version,
+    help: args.h || args.help || process.argv.length === 2,
+    create: args.c || args.c,
+    run: args.r || args.run,
+    dir: args.dir || process.cwd(),
+    functionName: args.function || args.f || undefined,
+    event: args.e || args.event,
+    template: args.t || args.template,
+    auth: args.auth || args.a,
+    deploy: args.d || args.deploy,
+    id: args.id,
+    secret: args.secret,
+    install: args.installDependency || false,
+  };
+};
+
+const showVersion = function () {
+  const require = createRequire(import.meta.url);
+  console.log(require("./package.json").version);
+};
+
+const showHelp = function () {
+  console.log(`Usage of usf-cli: usf-cli [option]
+
+Usage:
+      -v                                           get the version of usf-cli
+      -h                                           list the instruction of usf-cli
+      -i                                           init function project
+      -c --f=<function-name>                       create function <function-name> & its test event data template
+      -c --f=<function-name> --t=<template>        create function <function-name> with specified template code (see Supported template code)  & its test event data template
+      -r --f=<function-name>                       run function <function-name> with default event data(./uos_test/<function-name>_event.json)
+      -r --f=<function-name> --e=<event-dir>       run function <function-name> with specified event data
+      -a --id=<app-id> --secret=<service-secret>   set app id and service secret for this project (used for generating auth token)
+      -d                                           upload current stateless functions to UOS platform with UOS auth and deploy automatically
+
+Supported template code:
+      crud_mongo                                template function code for uos crud(mongo db version)
+      crud_mysql                                template function code for uos crud(mysql db version)
+      crud_postgresql                           template function code for uos crud(postgresql db version)
+      crud_redis                                template function code for uos crud(redis version)
+`);
+};
+
+const initProject = function () {
+  spawn("npm", ["init"], {
+    shell: true,
+    stdio: "inherit",
+  });
+};
+
+const createFunction = function () {
+  if (!this.dir) {
+    console.error(
+      `please specify the directory of stateless project with "--dir"`
+    );
+    return;
+  }
+
+  if (!this.functionName) {
+    console.error(`please specify the function name with "--f"`);
+    return;
+  }
+  create(this.dir, this.functionName, this.template);
+};
+
+const runFunction = async function () {
+  if (!this.dir) {
+    console.error(
+      `please specify the directory of stateless project with "--dir"`
+    );
+    return;
+  }
+
+  if (!this.functionName) {
+    console.error(`please specify the function name with "--f"`);
+    return;
+  }
+  let filePath = this.event
+    ? path.resolve(this.event)
+    : path.join(this.dir, `.uos_test/${this.functionName}_event.json`);
+  const event = (await loader(filePath)) || {};
+  dynamicRunner(`${this.dir}/${this.functionName}`, event);
+};
+
+const setAuthInfo = async function () {
+  if (!this.id) {
+    console.error(
+      `Please specify app id with "--id".\n\nIf not sure about app id, you can go to uos dev portal(https://uos.unity.cn/apps) to find your apps and get app id.`
+    );
+    return;
+  }
+  if (!this.secret) {
+    console.error(
+      `please specify app service secret with "--secret".\n\nIf not sure about app service secret, you can go to uos dev portal(https://uos.unity.cn/apps) to find your apps and get app service secret in setting tab of app detail page.`
+    );
+    return;
+  }
+  recordAuthInfoToFile(this.id, this.secret);
+};
+
+const deployFunction = async function () {
+  if (!this.dir) {
+    console.error(
+      `please specify the directory of stateless project with "--dir"`
+    );
+    return;
+  }
+  const auth = (await getAuthInfoFromFile()) || {};
+  if (!auth.id || !auth.secret) {
+    console.error(
+      `Please specify app id and secret with "usf-cli -a --id=<app-id> --secret=<service-secret>".\n\nIf not sure about app id and secret, you can go to uos dev portal(https://uos.unity.cn/apps) to find your apps and get app id and app service secret in setting tab of app detail page..`
+    );
+    return;
+  }
+  deployFunctionsToPlatform(this.dir, auth, this.install);
+};
+
+const main = async function () {
+  const args = parseArguments();
+
+  const commandMap = {
+    version: showVersion,
+    help: showHelp,
+    init: initProject.bind(args),
+    create: createFunction.bind(args),
+    run: runFunction.bind(args),
+    auth: setAuthInfo.bind(args),
+    deploy: deployFunction.bind(args),
+  };
+
+  for (let command in commandMap) {
+    if (args[command]) {
+      commandMap[command]();
+      return;
+    }
+  }
+
+  showHelp();
+};
+main();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "usf-cli",
+  "version": "1.1.3",
+  "description": "usf-cli helps uos stateless function developers with local running, boosting their development efficiency.",
+  "main": "index.js",
+  "bin": {
+    "usf-cli": "./index.js"
+  },
+  "scripts": {
+    "test": "test"
+  },
+  "keywords": [
+    "cli"
+  ],
+  "type": "module",
+  "author": "salanx.shi@uos",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.7.2",
+    "child_process": "^1.0.2",
+    "cos-nodejs-sdk-v5": "^2.14.4",
+    "jszip": "^3.10.1",
+    "minimist": "^1.2.8",
+    "module": "^1.1.0",
+    "path": "^0.12.7",
+    "read-pkg-up": "^11.0.0",
+    "semver": "^7.6.1",
+    "url": "^0.11.3"
+  }
+}

package/templates/crud_mongo.js

@@ -0,0 +1,36 @@
+exports.main = async (event, context) => {
+  context.database = require('func-stateless-mongodb-sdk-nodejs').database;
+  // If you do not specify a databaseId, the sdk will automatically search for and connect to an available database.
+  // 如果没有指定 databaseId 的话，sdk 会自动获取可用的数据库进行连接。
+  // Please note: if uos is authorized to store your database password in an encrypted form, this SDK will automatically fill in the password, if not authorized, you will need to specify the database password in your code
+  // 注意：如果uos被授权以加密形式存储您的数据库密码，本sdk将自动填入密码，如果未被授权，您需要在代码中指定数据库密码。
+  // Please note: if there are multiple available mongo databases, you must use the databaseId to specify the desired database you wish to connect to.
+  // 注意：如果有多个可用的 mongo 数据库的话，请在代码中指定要用于连接的数据库的 databaseId
+  const databaseId = '';
+  const databasePassword = '';
+  try {
+    const database = await context.database(databaseId, databasePassword);
+    const client = await database.connection();
+    try {
+      const db = await client.db('mongo');
+      const collection = await db.createCollection('myCollection');
+
+      const insertResult = await collection.insertOne({
+        name: 'Alice',
+        age: 25,
+      });
+      console.log('db insert result:', insertResult.acknowledged);
+
+      const findResult = await collection.findOne({ name: 'Alice' });
+      console.log('db query documents:', findResult);
+    } catch (error) {
+      console.error(error);
+    }
+
+    //test end pool
+    await database.endConnection();
+    console.log('closed the connection pool');
+  } catch (error) {
+    console.error(error);
+  }
+};

package/templates/crud_mysql.js

@@ -0,0 +1,60 @@
+exports.main = async (event, context) => {
+  context.database = require('func-stateless-mysql-sdk-nodejs').database;
+  // If you do not specify a databaseId, the system will automatically search for and connect to an available database.
+  // 如果没有指定 databaseId 的话，sdk 会自动获取可用的数据库进行连接。
+  // Please note: if uos is authorized to store your database password in an encrypted form, this SDK will automatically fill in the password, if not authorized, you will need to specify the database password in your code.
+  // 注意：如果uos被授权以加密形式存储您的数据库密码，本sdk将自动填入密码，如果未被授权，您需要在代码中指定数据库密码。
+  // Please note: if there are multiple available mysql databases, you must use the databaseId to specify the desired database you wish to connect to.
+  // 注意：如果有多个可用的 mysql 数据库的话，请在代码中指定要用于连接的数据库的 databaseId
+  const databaseId = '';
+  const databasePassword = '';
+  try {
+    const database = await context.database(databaseId, databasePassword);
+    const connection = await database.connection();
+    try {
+      const databaseName = 'test';
+      await connection.query(
+        `CREATE DATABASE IF NOT EXISTS \`${databaseName}\``
+      );
+      console.log(`Database ${databaseName} ensured.`);
+
+      await connection.query(`USE \`${databaseName}\``);
+      console.log(`Using database ${databaseName}`);
+
+      const createTableQuery = `
+         CREATE TABLE IF NOT EXISTS users (
+           id INT AUTO_INCREMENT PRIMARY KEY,
+           name VARCHAR(255) NOT NULL,
+           email VARCHAR(255) NOT NULL UNIQUE
+         )
+       `;
+      await connection.query(createTableQuery);
+      console.log('table created successfully');
+
+      const insertQuery = `INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com')`;
+      await connection.query(insertQuery);
+      console.log('rows inserted successfully');
+
+      const [rows] = await connection.query('SELECT * FROM users');
+      console.log('selected rows:', rows);
+
+      const deleteTableQuery = `
+         DROP TABLE IF EXISTS users
+       `;
+      await connection.query(deleteTableQuery);
+      console.log('table deleted successfully');
+    } catch (error) {
+      console.error('error while setting up the database:', error);
+    } finally {
+      // Please note: mysql connection should be released manually if you successfully check it out, regardless of whether there was an error with the queries you ran on the client.
+      // 注意：mysql 客户端需要被手动释放，无论查询过程是否发生错误
+      await connection.release();
+    }
+
+    //test end pool
+    await database.endConnection();
+    console.log('closed the connection pool');
+  } catch (error) {
+    console.error(error);
+  }
+};

package/templates/crud_postgresql.js

@@ -0,0 +1,30 @@
+exports.main = async (event, context) => {
+  context.database = require('func-stateless-postgresql-sdk-nodejs').database;
+  // If you do not specify a databaseId, the system will automatically search for and connect to an available database.
+  // 如果没有指定 databaseId 的话，sdk 会自动获取可用的数据库进行连接。
+  // Please note: if uos is authorized to store your database password in an encrypted form, this SDK will automatically fill in the password, if not authorized, you will need to specify the database password in your code
+  // 注意：如果uos被授权以加密形式存储您的数据库密码，本sdk将自动填入密码，如果未被授权，您需要在代码中指定数据库密码。
+  // Please note: if there are multiple available postgresql databases, you must use the databaseId to specify the desired database you wish to connect to.
+  // 注意：如果有多个可用的 postgresql 数据库的话，请在代码中指定要用于连接的数据库的 databaseId
+  const databaseId = '';
+  const databasePassword = '';
+  try {
+    const database = await context.database(databaseId, databasePassword);
+    const connection = await database.connection();
+    try {
+      const result = await connection.query('SELECT tablename FROM pg_tables');
+      console.log('db query result:', result.rows);
+    } catch (error) {
+      console.error('failed to query data, error:' + error);
+    } finally {
+      // Please note: psql client should be released manually if you successfully check it out, regardless of whether there was an error with the queries you ran on the client.
+      // 注意：postgresql 客户端需要被手动释放，无论查询过程是否发生错误
+      await connection.release();
+    }
+    // test end pool
+    await database.endConnection();
+    console.log('closed the connection pool');
+  } catch (error) {
+    console.error(error);
+  }
+};

package/templates/crud_redis.js

@@ -0,0 +1,32 @@
+exports.main = async (event, context) => {
+  context.database = require('func-stateless-redis-sdk-nodejs').database;
+  // If you do not specify a databaseId, the system will automatically search for and connect to an available database.
+  // 如果没有指定 databaseId 的话，sdk 会自动获取可用的数据库进行连接。
+  // Please note: if uos is authorized to store your database password in an encrypted form, this SDK will automatically fill in the password, if not authorized, you will need to specify the database password in your code
+  // 注意：如果uos被授权以加密形式存储您的数据库密码，本sdk将自动填入密码，如果未被授权，您需要在代码中指定数据库密码。
+  // Please note: if there are multiple available redis, you must use the databaseId to specify the desired database you wish to connect to.
+  // 注意：如果有多个可用的 redis 的话，请在代码中指定要用于连接的 databaseId
+  const databaseId = '';
+  const databasePassword = '';
+  try {
+    const database = await context.database(databaseId, databasePassword);
+    const client = await database.connection();
+    try {
+      await client.set('someKey', 'someValue');
+      const result = await client.get('someKey');
+      console.log('db query result:', result);
+    } catch (error) {
+      console.error('failed to query data, error:' + error);
+    } finally {
+      // Please note: redis client should be released manually if you successfully check it out, regardless of whether there was an error with the queries you ran on the client.
+      // 注意：redis客户端需要被手动释放，无论查询过程是否发生错误
+      await client.release();
+    }
+
+    // test end pool
+    await database.endConnection();
+    console.log('closed the connection pool');
+  } catch (error) {
+    console.error(error);
+  }
+};

package/templates/default.js

@@ -0,0 +1,9 @@
+exports.main = async function (event, context) {
+  const { httpMethod,headers, body } = event;
+
+  console.log('Http method:', httpMethod);
+  console.log('Http headers:', JSON.stringify(headers));
+  console.log('Request body', JSON.stringify(body));
+
+  return 'hello world';
+};

package/utils/dynamic-runner/index.js

@@ -0,0 +1,89 @@
+import path from "path";
+import semver from "semver";
+import { readPackageUp } from "read-pkg-up";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+
+function getFunctionModulePath(codeLocation) {
+  try {
+    return require.resolve(codeLocation);
+  } catch (ex) {}
+
+  try {
+    return require.resolve(codeLocation + "/index.js");
+  } catch (ex) {}
+
+  return null;
+}
+
+const dynamicImport = new Function("modulePath", "return import(modulePath)");
+
+async function isEsModule(modulePath) {
+  const ext = path.extname(modulePath);
+  if (ext === ".mjs") {
+    return true;
+  }
+  if (ext === ".cjs") {
+    return false;
+  }
+
+  const pkg = await readPackageUp({
+    cwd: path.dirname(modulePath),
+    normalize: false,
+  });
+  return pkg?.packageJson.type === "module";
+}
+
+const dynamicRunner = async function (path, event = {}, entry = "main") {
+  const functionModulePath = getFunctionModulePath(path);
+  if (functionModulePath === null) {
+    console.error(`'${path}' is not a loadable module.`);
+    return;
+  }
+
+  let functionModule;
+  const esModule = await isEsModule(functionModulePath);
+  if (esModule) {
+    if (semver.lt(process.version, MIN_NODE_VERSION_ESMODULES)) {
+      console.error(
+        `Cannot load ES Module on Node.js ${process.version}. ` +
+          `Please upgrade to Node.js v${MIN_NODE_VERSION_ESMODULES} and up.`
+      );
+      return null;
+    }
+    const fpath = pathToFileURL(functionModulePath);
+    functionModule = await dynamicImport(fpath.href);
+  } else {
+    functionModule = require(functionModulePath);
+  }
+  const userFunction = entry.split(".").reduce((code, functionTargetPart) => {
+    if (typeof code === "undefined") {
+      return undefined;
+    } else {
+      return code[functionTargetPart];
+    }
+  }, functionModule);
+
+  if (typeof userFunction === "undefined") {
+    console.error(`Function '${path}' not found.`);
+    return;
+  }
+
+  if (typeof userFunction !== "function") {
+    console.error(
+      `'${path}/${entry}' needs to be of type function. Got: ` +
+        `${typeof userFunction}`
+    );
+    return;
+  }
+
+  console.log(`Function '${path}/${entry}' is running：`);
+  console.log("\n=================Event:");
+  console.log(event);
+  const res = await userFunction(event, {});
+  console.log(`\n=================Return：\n${JSON.stringify(res)}`);
+};
+
+export { dynamicRunner };

package/utils/function-construct/index.js

@@ -0,0 +1,120 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { spawn } from "child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const event = {
+  body: "",
+  headerParameters: {},
+  headers: {},
+  httpMethod: "GET",
+  isBase64Encoded: false,
+  pathParameters: {},
+  queryString: {},
+  queryStringParameters: {},
+};
+
+const repository = {
+  crud_mongo: "func-stateless-mongodb-sdk-nodejs",
+  crud_mysql: "func-stateless-mysql-sdk-nodejs",
+  crud_postgresql: "func-stateless-postgresql-sdk-nodejs",
+  crud_redis: "func-stateless-redis-sdk-nodejs",
+};
+
+const makeFile = async function (dir, folderName, fileName, overwrite=false) {
+  const folder = path.join(dir, folderName);
+  if (!fs.existsSync(folder)) {
+    fs.mkdirSync(folder);
+  }
+  const file = path.join(folder, fileName);
+  if (!overwrite && fs.existsSync(file)) {
+    console.log(
+      `"./${folderName}/${fileName}" is existed. Running 'vim ./${folderName}/${fileName}' to edit it.\n`
+    );
+    throw new Error("File is existed");
+  }
+  return file;
+};
+
+const createFile = async function (dir, folderName, fileName, conent) {
+  try {
+    const file = await makeFile(dir, folderName, fileName);
+    fs.writeFile(file, conent, (err) => {
+      if (err) {
+        console.error(`Fail to init './${folderName}${fileName}':\n`, err);
+        return;
+      }
+      console.log(
+        `"./${folderName}${fileName}" has inited. Running 'vim ./${folderName}${fileName}' to edit it.\n`
+      );
+    });
+  } catch (e) {
+    console.log(e);
+  }
+};
+
+const copyFile = async function (dir, folderName, fileName, template) {
+  try {
+    const file = await makeFile(dir, folderName, fileName);
+    const templatePath = path.resolve(
+      __dirname,
+      `../../templates/${template}.js`
+    );
+    if (!fs.existsSync(templatePath)) {
+      console.log("template is not found");
+      return;
+    }
+    fs.copyFile(templatePath, file, (err) => {
+      if (err) {
+        console.error(`Fail to init function with template:\n`, err);
+        return;
+      }
+      console.log(
+        `"./${folderName}${fileName}" data has inited. Running 'vim ./${folderName}${fileName}' to edit it.\n`
+      );
+
+      // auto install dependency of stateless sdk
+      if (repository[template]) {
+        spawn("npm", ["install", repository[template]], {
+          shell: true,
+          stdio: "inherit",
+        });
+      }
+    });
+  } catch (e) {
+    console.log(e);
+  }
+};
+
+const create = async function (dir, functionName, template) {
+  template = template || "default";
+  copyFile(dir, `${functionName}/`, `index.js`, template);
+  createFile(
+    dir,
+    ".uos_test/",
+    `${functionName}_event.json`,
+    JSON.stringify(event, null, 2)
+  );
+};
+
+const loader = function (filePath) {
+  return new Promise((resolve, reject) => {
+    try {
+      fs.readFile(filePath, "utf8", (err, data) => {
+        if (err) {
+          resolve(undefined);
+          return;
+        }
+
+        resolve(JSON.parse(data));
+      });
+    } catch (e) {
+      resolve(undefined);
+    }
+  });
+};
+
+export { create, loader, makeFile };

package/utils/uploader/index.js

@@ -0,0 +1,359 @@
+import { makeFile, loader } from "../function-construct/index.js";
+import os from "os";
+import fs from "fs";
+import path from "path";
+import JSZip from "jszip";
+import axios from "axios";
+import COS from "cos-nodejs-sdk-v5";
+
+const igonreList = [
+  ".DS_Store",
+  ".idea",
+  ".vscode",
+  ".git",
+  "package-lock.json",
+  ".uos_test",
+];
+let hasPackageJson = false;
+let hasNodeModules = false;
+
+const recordAuthInfoToFile = async function (id, secret) {
+  const tempDir = os.tmpdir();
+  const auth = { id: id, secret: secret };
+  try {
+    const file = await makeFile(tempDir, ".uos", "auth.json", true);
+    fs.writeFile(file, JSON.stringify(auth, null, 2), (err) => {
+      if (err) {
+        console.error(`Fail to record auth info.`);
+        return;
+      }
+      console.log(
+        `Auth info is recorded.\n\nIf stateless functions are completed, you can run "usf-cli -u" to upload them to UOS platform with UOS auth and deploy automatically.`
+      );
+    });
+  } catch (e) {
+    console.log(e);
+  }
+};
+
+const getAuthInfoFromFile = async function () {
+  const tempDir = os.tmpdir();
+  const authPath = path.join(tempDir, ".uos", "auth.json");
+  const authInfo = await loader(authPath);
+
+  return authInfo;
+};
+
+const convertToValidVariableName = function (folderName) {
+  // 移除非法字符并确保以合法字符开头
+  let validName = folderName.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^[0-9_$]/.test(validName)) {
+    validName = "_" + validName; // 如果以数字、下划线或美元符号开头，则添加下划线作为前缀
+  }
+  return validName;
+};
+
+const formatHandler = function (name, entry) {
+  return `const { main: ${name} } = require("./${entry}/index.js");\n\nexports.${name}_handler = ${name};\n\n`;
+};
+
+const zipDirectory = async function (entries, zip, dir, level = 0) {
+  const files = fs.readdirSync(dir);
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stats = fs.statSync(filePath);
+    if (igonreList.includes(file)) {
+      continue;
+    }
+    if (level === 0 && file === "package.json") {
+      hasPackageJson = true;
+    }
+    if (level === 0 && file === "node_modules") {
+      hasNodeModules = true;
+    }
+    if (stats.isDirectory()) {
+      const isEntry = await zipDirectory(
+        entries,
+        zip.folder(file),
+        filePath,
+        level + 1
+      );
+      if (isEntry) {
+        entries[file] = convertToValidVariableName(file);
+      }
+    } else {
+      const content = fs.readFileSync(filePath);
+      zip.file(file, content);
+    }
+  }
+  return level === 1 && files.includes("index.js");
+};
+
+const creatZip = async function (dir) {
+  const zip = new JSZip();
+  const entries = {};
+
+  dir = dir || process.cwd();
+
+  await zipDirectory(entries, zip, dir);
+  let entryFile = "";
+  for (let entry in entries) {
+    entryFile += formatHandler(entries[entry], entry);
+  }
+  zip.file(path.relative(dir, "index.js"), entryFile);
+  const zipContent = await zip.generateAsync({ type: "nodebuffer" });
+
+  return { entries, zipContent };
+};
+
+const getToken = async function (auth) {
+  const res = await axios.get(
+    "https://func.unity.cn/v1/func-stateless/functions/" +
+      auth.id +
+      "/get-transfer-token",
+    {
+      headers: {
+        Authorization: "Basic " + btoa(auth.id + ":" + auth.secret),
+      },
+    }
+  );
+  return res.data;
+};
+
+const uploadZipToCos = function (cosToken, zipContent) {
+  const cos = new COS({
+    getAuthorization: function (options, callback) {
+      callback({
+        TmpSecretId: cosToken.tmpSecretId,
+        TmpSecretKey: cosToken.tmpSecretKey,
+        SecurityToken: cosToken.token,
+        StartTime: cosToken.startTime,
+        ExpiredTime: Math.ceil(Date.parse(cosToken.expiredTime) / 1000),
+      });
+    },
+  });
+  let taskId;
+  return new Promise((resolve, reject) => {
+    cos.putObject(
+      {
+        Bucket: cosToken.bucket,
+        Region: cosToken.region,
+        Key: cosToken.objectName + `/${path.basename(process.cwd())}.zip`,
+        Body: zipContent,
+        onTaskReady: function (taskId) {
+          taskId = taskId;
+        },
+      },
+      function (err, data) {
+        if (err) {
+          reject(err);
+        } else {
+          taskId = null;
+          setTimeout(() => {
+            resolve();
+          }, 500);
+        }
+      }
+    );
+  });
+};
+
+const createScf = async function (auth, entries) {
+  let payLoad = {
+    scfList: [],
+  };
+
+  for (let entry in entries) {
+    payLoad.scfList.push({
+      name: entries[entry],
+      zipName: path.basename(process.cwd()),
+      handler: `index.${entries[entry]}_handler`,
+    });
+  }
+
+  await axios.post(
+    "https://func.unity.cn/v1/func-stateless/functions/" + auth.id + "/scf",
+    payLoad,
+    {
+      headers: {
+        Authorization: "Basic " + btoa(auth.id + ":" + auth.secret),
+      },
+    }
+  );
+};
+
+const loadingAnimation = function (loadingLabel) {
+  const frames = ["-", "\\", "|", "/"];
+  let i = 0;
+
+  const interval = setInterval(() => {
+    process.stdout.write(`\r${frames[i]} ${loadingLabel}...`);
+    i = (i + 1) % frames.length;
+  }, 100);
+
+  return interval;
+};
+
+const checkFunctionStatus = function (auth) {
+  return new Promise((resolve, reject) => {
+    const getFunctionInfo = async () => {
+      try {
+        const res = await axios.get(
+          "https://func.unity.cn/v1/func-stateless/functions/" + auth.id,
+          {
+            headers: {
+              Authorization: "Basic " + btoa(auth.id + ":" + auth.secret),
+            },
+          }
+        );
+
+        if (res?.data?.functionInfo?.status === "createFailed") {
+          reject();
+        } else if (res?.data?.functionInfo?.status === "creating") {
+          setTimeout(getFunctionInfo, 3000);
+        } else {
+          resolve(res?.data?.functionInfo);
+        }
+      } catch (e) {
+        reject(e);
+      }
+    };
+    getFunctionInfo();
+  });
+};
+
+const updateInstallDependency = async function (install = false, auth) {
+  let payload = {
+    functionInfo: {
+      options: {
+        installDependency: install ? "TRUE" : "FALSE",
+      },
+    },
+  };
+
+  await axios.put(
+    "https://func.unity.cn/v1/func-stateless/functions/" + auth.id,
+    payload,
+    {
+      headers: {
+        Authorization: "Basic " + btoa(auth.id + ":" + auth.secret),
+      },
+    }
+  );
+};
+
+const stepWrapper = async function (stepHandler, args, loading, done) {
+  let id = loadingAnimation(loading);
+  try {
+    const res = await stepHandler(...args);
+    clearInterval(id);
+    console.log(`\r>>> Success to ${done}!`);
+    return res;
+  } catch (e) {
+    clearInterval(id);
+    console.error(`\r>>> Failed to ${done}: \n`, e.response || e);
+    process.exit(1);
+  }
+};
+
+const listFunctions = async function (version, auth) {
+  try {
+    const params = {
+      version: version,
+    };
+    const res = await axios.get(
+      `https://func.unity.cn/v1/func-stateless/functions/${auth.id}/scf`,
+      {
+        params: params,
+        headers: {
+          Authorization: "Basic " + btoa(auth.id + ":" + auth.secret),
+        },
+      }
+    );
+    const scfs = res.data.scfs || [];
+    console.log(
+        `\n====== Successfully deployed ${scfs.length} function(s). Current Online Func version is: ${version} ======\n`
+    );
+
+    for (const scf of scfs) {
+      console.log(`Function Name: ${scf.name}\nFunction URL: ${scf.url}\n`);
+    }
+    console.log(`============ Deployment completed ============\n`);
+  } catch (error) {
+    console.log(error.response);
+  }
+};
+
+const deployFunctionsToPlatform = async function (dir, auth, install = false) {
+  hasNodeModules = false;
+  hasPackageJson = false;
+
+  console.log(`\n============ Deployment starts  ============\n`);
+
+  const { entries, zipContent } = await stepWrapper(
+    creatZip,
+    [dir],
+    "Packaging current project",
+    "package current project"
+  );
+
+  if (!hasNodeModules && !hasPackageJson) {
+    console.error("!!! Can't find package.json & node_modules/ in your project.");
+    process.exit(1);
+  }
+
+  if (hasNodeModules ^ hasPackageJson) {
+    install = hasPackageJson;
+  }
+
+  await stepWrapper(
+    updateInstallDependency,
+    [install, auth],
+    `Changing 'Online Install Dependency' status to ${
+      install ? "TRUE" : "FALSE"
+    }`,
+    `change 'Online Install Dependency' status to ${install ? "TRUE" : "FALSE"}`
+  );
+
+  if (install) {
+    igonreList.push("node_modules");
+  }
+
+  // const zipFilePath = path.join(process.cwd(), `/${path.basename(process.cwd())}.zip`);
+  // fs.writeFileSync(zipFilePath, zipContent);
+
+  const cosToken = await stepWrapper(
+    getToken,
+    [auth],
+    "Getting cos token",
+    "get cos token"
+  );
+
+  await stepWrapper(
+    uploadZipToCos,
+    [cosToken, zipContent],
+    "Uploading function project to cos",
+    "upload function project to cos"
+  );
+
+  await stepWrapper(
+    createScf,
+    [auth, entries],
+    "Updating Func Stateless",
+    "update Func Stateless"
+  );
+
+  const functionInfo = await stepWrapper(
+    checkFunctionStatus,
+    [auth],
+    "Deploying functions",
+    "deploy functions"
+  );
+
+  if (functionInfo.currentVersion) {
+    await listFunctions(functionInfo.currentVersion, auth);
+  }
+};
+
+export { recordAuthInfoToFile, getAuthInfoFromFile, deployFunctionsToPlatform };