usf-cli 1.2.0 → 1.2.2

package/templates/crud_mongo.js

@@ -1,36 +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);
-  }
+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

@@ -1,60 +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);
-  }
+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

@@ -1,30 +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);
-  }
+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

@@ -1,32 +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);
-  }
+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

@@ -1,9 +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';
+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

@@ -1,89 +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 };
+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 };