endpoints-sdk-cli 3.0.0-alpha-2.0 → 3.0.0

package/README.md

@@ -0,0 +1,84 @@
+# matsuri-tech/endpoints-sdk-cli (mes)
+
+Endpoints SDK for JavaScript
+
+## Usage
+
+```shell
+pnpm add -D endpoints-sdk-cli
+npx mes --help
+```
+
+## Commands
+
+- [`mes init`](#mes-init)
+- [`mes add [REPOSITORY]`](#mes-add-repository)
+- [`mes install`](#mes-install)
+- [`mes update [SERVICE]`](#mes-update-service)
+
+### `mes init`
+
+initialize endpoints.config.json
+
+```shell
+npx mes init
+```
+
+### `mes add [REPOSITORY]`
+
+add service to dependencies & make endpoints files.
+
+```shell
+npx mes add [REPOSITORY]
+```
+
+Examples:
+
+```shell
+mes add [username/repository_name]
+mes add [username/repository_name] -b [branch_name]
+mes add [username/repository_name] -w [workspace_name]
+mes add [username/repository_name] -e [period_name]
+```
+
+### `mes install`
+
+generate endpoints files based on endpoints.config.json
+
+```shell
+npx mes install
+```
+
+### `mes update [SERVICE]`
+
+update service version & regenerate endpoints files
+
+```shell
+npx mes update [SERVICE]
+```
+
+## Support of `create-react-app`
+
+```json
+{
+  "environment_identifier": "process.env.REACT_APP_ENV"
+}
+```
+
+## Override root url
+
+```json
+{
+  "dependencies": {
+    "my-service": {
+      "version": "ba832b61d0319f42b3cbb30c815cbdecfece959a",
+      "repository": "git@github.com:hoge/my-service.git",
+      "roots": {
+        "dev": "https://dev.hoge.com",
+        "prod": "https://hoge.com",
+        "local": "http://localhost:3000"
+      }
+    }
+  }
+}
+```

package/dist/index.cjs

@@ -0,0 +1,541 @@
+#! /usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var package_default = {
+  name: "endpoints-sdk-cli",
+  description: "endpoints sdk cli",
+  version: "3.0.0",
+  type: "module",
+  author: "hrdtbs",
+  bin: {
+    mes: "./dist/index.cjs"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    test: "vitest",
+    lint: "eslint .",
+    postlint: "prettier --check .",
+    format: "eslint . --fix",
+    postformat: "prettier --write .",
+    coverage: "vitest --coverage",
+    build: "tsup src/index.ts --out-dir dist",
+    typecheck: "tsc --noEmit"
+  },
+  devDependencies: {
+    "@types/node": "22.7.8",
+    "@vitest/coverage-v8": "2.1.3",
+    eslint: "9.17.0",
+    "eslint-config-matsuri": "5.4.0",
+    prettier: "3.4.2",
+    tsup: "8.4.0",
+    typescript: "^5.6.3",
+    vitest: "2.1.9"
+  },
+  dependencies: {
+    "@apidevtools/json-schema-ref-parser": "11.7.3",
+    commander: "12.1.0",
+    "json-schema-to-typescript": "15.0.3"
+  }
+};
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/model/config.ts
+var createConfigOption = () => {
+  return {
+    output: "./endpoints/",
+    environment_identifier: "process.env.NODE_ENV",
+    dependencies: {}
+  };
+};
+var Config = class {
+  $schema;
+  output;
+  environment_identifier;
+  dependencies;
+  constructor(option = createConfigOption()) {
+    this.$schema = "https://matsuri-tech.github.io/endpoints-sdk-cli/schema.json";
+    this.output = option.output;
+    this.environment_identifier = option.environment_identifier;
+    this.dependencies = option.dependencies;
+  }
+  push(name, service) {
+    this.dependencies[name] = service;
+  }
+  json() {
+    return JSON.stringify(this, null, 2);
+  }
+};
+
+// src/executers/config.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var CONFIG_FILE_NAME = "endpoints.config.json";
+var writeConfigFile = async (config) => {
+  await import_promises.default.writeFile(CONFIG_FILE_NAME, config.json());
+};
+var createConfigFile = async () => {
+  const config = new Config();
+  await writeConfigFile(config);
+};
+var readConfigFile = async () => {
+  const content = await import_promises.default.readFile(CONFIG_FILE_NAME, "utf-8");
+  return new Config(JSON.parse(content));
+};
+
+// src/commands/init.ts
+var init = async () => {
+  await createConfigFile();
+};
+
+// src/executers/repository/getHeadCommitHash.ts
+var import_child_process = require("child_process");
+function getHeadCommitHash(repositoryPath) {
+  const output = (0, import_child_process.execSync)("git rev-parse HEAD", { cwd: repositoryPath });
+  return output.toString().trim();
+}
+
+// src/executers/repository/detectMainBranch.ts
+var import_child_process2 = require("child_process");
+function detectMainBranch(repositoryPath) {
+  const output = (0, import_child_process2.execSync)("git rev-parse --abbrev-ref HEAD", {
+    cwd: repositoryPath
+  });
+  return output.toString().trim();
+}
+
+// src/executers/repository/cloneRepository.ts
+var import_child_process3 = require("child_process");
+function cloneRepository(sshPath) {
+  console.info(`git clone ${sshPath}...`);
+  const cache = `node_modules/.endpoints-tmp/${(/* @__PURE__ */ new Date()).getTime()}`;
+  const result = (0, import_child_process3.spawnSync)("git", [
+    "clone",
+    "--no-checkout",
+    "--quiet",
+    sshPath,
+    cache
+  ]);
+  const error = result.stderr.toString();
+  if (error) {
+    throw new Error(`Failed to clone repository: ${error}`);
+  }
+  console.info(`git clone ${sshPath} done!`);
+  return cache;
+}
+
+// src/executers/repository/getRepositoryData.ts
+var import_child_process4 = require("child_process");
+var fs2 = __toESM(require("fs"), 1);
+
+// src/executers/repository/parseJsonSchema.ts
+var import_json_schema_ref_parser = __toESM(require("@apidevtools/json-schema-ref-parser"), 1);
+async function parseJsonSchema(data) {
+  const parsed = await import_json_schema_ref_parser.default.dereference(data);
+  if ("$defs" in parsed) {
+    delete parsed.$defs;
+  }
+  return parsed;
+}
+
+// src/executers/repository/getRepositoryData.ts
+async function getRepositoryData(repositoryPath, branchName, workspace, commitHash) {
+  const endpointsFile = workspace !== void 0 ? `./${workspace}/.endpoints.json` : "./.endpoints.json";
+  const checkoutResult = (0, import_child_process4.spawnSync)(
+    "git",
+    ["checkout", branchName, "--", endpointsFile],
+    { cwd: repositoryPath }
+  );
+  if (checkoutResult.status !== 0) {
+    console.error(checkoutResult.stderr.toString());
+    throw new Error("Failed to checkout");
+  }
+  if (commitHash !== void 0) {
+    const resetResult = (0, import_child_process4.spawnSync)("git", ["reset", "--hard", commitHash], {
+      cwd: repositoryPath
+    });
+    if (resetResult.status !== 0) {
+      console.error(resetResult.stderr.toString());
+      throw new Error("Failed to git reset");
+    }
+  }
+  const targetFile = workspace !== void 0 ? `${repositoryPath}/${workspace}/.endpoints.json` : `${repositoryPath}/.endpoints.json`;
+  const contents = fs2.readFileSync(targetFile, "utf-8");
+  const setting = JSON.parse(contents);
+  return parseJsonSchema(setting);
+}
+
+// src/utils/toCamelCase.ts
+var toCamelCase = (str) => {
+  let first = false;
+  let result = "";
+  for (const s of str) {
+    if (first) {
+      result += s.toUpperCase();
+      first = false;
+    } else if (s === "-" || s === "_") {
+      first = true;
+    } else {
+      result += s;
+    }
+  }
+  return result;
+};
+
+// src/templates/functions/endpoint/parsePathParams.ts
+var parsePathParams = (path2) => {
+  return path2.split("/").filter((segment) => segment.startsWith(":")).map((param) => {
+    return {
+      name: param.slice(1),
+      param_type: "string"
+    };
+  });
+};
+
+// src/templates/functions/endpoint/detectParamType.ts
+var detectParamType = (example) => {
+  if (!isNaN(Number(example))) {
+    return "number";
+  } else {
+    return "string";
+  }
+};
+
+// src/templates/functions/endpoint/parseQueryParams.ts
+var parseQueryParams = (query) => {
+  return query.split("&").map((param) => {
+    const [name, example] = param.split("=");
+    return {
+      name,
+      example,
+      param_type: example !== void 0 ? detectParamType(example) : "string"
+    };
+  });
+};
+
+// src/templates/functions/endpoint/createEndpoint.ts
+var import_json_schema_to_typescript = require("json-schema-to-typescript");
+async function createEndpoint(name, endpoint) {
+  const pv = endpoint.path.split("?");
+  const endpointPath = pv[0];
+  const queryParams = pv.length > 1 ? parseQueryParams(pv[1]) : [];
+  const pathParams = parsePathParams(endpointPath);
+  const paramNames = [];
+  const queryParamNames = [];
+  const params = [];
+  for (const param of queryParams) {
+    if (!paramNames.includes(param.name)) {
+      paramNames.push(param.name);
+      queryParamNames.push(param.name);
+      params.push(param);
+    }
+  }
+  const pathParamNames = [];
+  for (const param of pathParams) {
+    if (!paramNames.includes(param.name)) {
+      paramNames.push(param.name);
+      pathParamNames.push(param.name);
+      params.push(param);
+    }
+  }
+  const description = endpoint.desc;
+  const queryParamsComment = queryParams.length > 0 ? queryParams.map(
+    (param) => `@param {${param.param_type}} ${param.name} ${param.example ?? ""}`
+  ).join("\n * ") : "";
+  const hasPrameters = paramNames.length > 0;
+  const parameters = paramNames.join(", ");
+  const parameterTypes = params.map(
+    (param) => `${param.name}${pathParamNames.includes(param.name) ? "" : "?"}: ${param.param_type}`
+  ).join(", ");
+  const queryParamNamesStr = queryParamNames.join(", ");
+  const pathTemplate = pathParams.reduce(
+    (template, param) => template.replace(`:${param.name}`, `\${${param.name}}`),
+    endpointPath
+  );
+  const request = endpoint.request ? await (0, import_json_schema_to_typescript.compile)(endpoint.request, `${name}Request`) : void 0;
+  const response = endpoint.response ? await (0, import_json_schema_to_typescript.compile)(endpoint.response, `${name}Response`) : void 0;
+  const func = `
+/**
+ * ${description}
+ * ${queryParamsComment}
+ */
+export const ${name} = (${hasPrameters ? `{${parameters}}: {${parameterTypes}}` : ``}) => {
+    const __root = root();
+    const __queries = Object.entries({${queryParamNamesStr}})
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => \`\${key}=\${value}\`)
+        .join("&");
+    const __path = \`\${__root}${pathTemplate}\`;
+    return __queries ? \`\${__path}?\${__queries}\` : __path;
+};`;
+  const method = endpoint.method !== void 0 ? `${name}.method = "${endpoint.method}" as const;` : false;
+  const authSchema = endpoint.authSchema !== void 0 ? `${name}.authSchema = ${JSON.stringify(endpoint.authSchema)} as const;` : false;
+  return [request, response, func, method, authSchema].filter(Boolean).join("\n");
+}
+
+// src/templates/functions/root/createRoot.ts
+var normalizeName = (name) => {
+  switch (name) {
+    case "dev": {
+      return "development";
+    }
+    case "prod": {
+      return "production";
+    }
+    default: {
+      return name;
+    }
+  }
+};
+var normalizePath = (path2) => {
+  if (path2.endsWith("/")) {
+    return path2.slice(0, -1);
+  } else {
+    return path2;
+  }
+};
+var createRoot = (environment_identifier, env, overrides) => {
+  const content = Object.entries(env).map(([key, value]) => {
+    const name = normalizeName(key);
+    const path2 = normalizePath(overrides?.[key] ?? value);
+    return `
+    if (${environment_identifier} === "${name}") {       
+        __root = "${path2}";
+    }`;
+  }).join("\n");
+  return `
+/**
+ * A function that returns the URL part common to the endpoints.
+ */
+export const root = () => {
+    let __root = "";
+    ${content}
+    return __root
+}`;
+};
+
+// src/templates/files/endpoints/createEndpointsContent.ts
+var createEndpointsContent = async (repositoryAlias, service, period, environmentIdentifier, version) => {
+  const names = [];
+  const functions = [];
+  const root = createRoot(environmentIdentifier, period.env, service.roots);
+  functions.push(root);
+  for (const [name, endpoint] of Object.entries(period.api)) {
+    const camelCaseName = toCamelCase(name);
+    names.push(camelCaseName);
+    const endpointFunc = await createEndpoint(camelCaseName, endpoint);
+    functions.push(endpointFunc);
+  }
+  const exports2 = `export const ${toCamelCase(repositoryAlias)}_${toCamelCase(
+    version
+  )} = {${names.join(",")}};`;
+  return `${functions.join("\n")}
+${exports2}`;
+};
+
+// src/executers/endpoint/getEndpointFilepath.ts
+function getEndpointFilepath(repositoryName, workspace, version, hasExtension = false) {
+  let baseName = repositoryName;
+  if (workspace !== void 0) {
+    baseName += `.${workspace}`;
+  }
+  if (version !== void 0) {
+    baseName += `.${version}`;
+  }
+  if (hasExtension) {
+    baseName += ".ts";
+  }
+  return baseName;
+}
+
+// src/utils/createFile.ts
+var fs3 = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+function createFile(output, filename, contents) {
+  if (!fs3.existsSync(output)) {
+    fs3.mkdirSync(output, { recursive: true });
+  }
+  const filePath = path.join(output, filename);
+  fs3.writeFileSync(filePath, contents);
+}
+
+// src/templates/files/index/createIndexContent.ts
+var createIndexContent = (repositoryAlias, filesMetadata) => {
+  const [indexImports, indexExportNames] = filesMetadata.reduce(
+    (acc, { version, filepath }) => {
+      const filepathWithoutExt = filepath.replace(/\.ts$/, "");
+      acc[0].push(
+        `import * as ${toCamelCase(version)} from './${filepathWithoutExt}';`
+      );
+      acc[1].push(toCamelCase(version));
+      return acc;
+    },
+    [[], []]
+  );
+  const importsClause = indexImports.join("\n");
+  const exportsClause = indexExportNames.join(",\n  ");
+  return `${importsClause}
+export const ${toCamelCase(repositoryAlias)} = {
+  ${exportsClause}
+};`;
+};
+
+// src/executers/endpoint/createEndpointFiles.ts
+async function createEndpointFiles(repositoryAlias, service, environmentIdentifier, output) {
+  const clonedRepositoryPath = cloneRepository(service.repository);
+  const commitHash = service.version ?? getHeadCommitHash(clonedRepositoryPath);
+  const branchName = service.branch ?? detectMainBranch(clonedRepositoryPath);
+  const workspace = service.workspaces ? service.workspaces[0] : void 0;
+  const repositoryData = await getRepositoryData(
+    clonedRepositoryPath,
+    branchName,
+    workspace,
+    service.version
+  );
+  const filesMetadata = [];
+  console.info(`generate endpoint files...`);
+  for (const [version, period] of Object.entries(repositoryData)) {
+    if (service.exclude_periods?.includes(version)) {
+      continue;
+    }
+    if (period.env === void 0 || period.api === void 0) continue;
+    const filepath = getEndpointFilepath(
+      repositoryAlias,
+      workspace,
+      version,
+      true
+    );
+    filesMetadata.push({
+      version,
+      filepath
+    });
+    const content = await createEndpointsContent(
+      repositoryAlias,
+      service,
+      period,
+      environmentIdentifier,
+      version
+    );
+    createFile(output, filepath, content);
+  }
+  createFile(
+    output,
+    getEndpointFilepath(repositoryAlias, void 0, void 0, true),
+    createIndexContent(repositoryAlias, filesMetadata)
+  );
+  console.info(`generate endpoint files done!`);
+  return {
+    ...service,
+    version: commitHash,
+    branch: branchName,
+    workspaces: workspace !== void 0 ? [workspace] : void 0
+  };
+}
+
+// src/commands/install.ts
+var install = async () => {
+  const config = await readConfigFile();
+  for (const [alias, service] of Object.entries(config.dependencies)) {
+    await createEndpointFiles(
+      alias,
+      service,
+      config.environment_identifier,
+      config.output
+    );
+  }
+};
+
+// src/commands/update.ts
+var update = async (alias) => {
+  const config = await readConfigFile();
+  const service = config.dependencies[alias];
+  const updated = await createEndpointFiles(
+    alias,
+    {
+      ...service,
+      version: void 0
+    },
+    config.environment_identifier,
+    config.output
+  );
+  config.push(alias, updated);
+  await writeConfigFile(config);
+};
+
+// src/executers/repository/getRepositoryPath.ts
+function getRepositoryPath(repositoryName) {
+  return `https://github.com/${repositoryName}`;
+}
+
+// src/executers/repository/getRepositoryAlias.ts
+function getRepositoryAlias(repositoryName) {
+  const alias = repositoryName.split("/").pop();
+  return alias ?? "";
+}
+
+// src/commands/add.ts
+var add = async (repositoryName, workspaces, branch, exclduePeriods) => {
+  const config = await readConfigFile();
+  const alias = getRepositoryAlias(repositoryName);
+  const repositoryPath = getRepositoryPath(repositoryName);
+  const service = await createEndpointFiles(
+    alias,
+    {
+      version: void 0,
+      repository: repositoryPath,
+      workspaces,
+      branch,
+      exclude_periods: exclduePeriods
+    },
+    config.environment_identifier,
+    config.output
+  );
+  config.push(alias, service);
+  await writeConfigFile(config);
+};
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name(package_default.name).description(package_default.description).version(package_default.version);
+program.command("init").action(init);
+program.command("add").description("Add a new service").argument("<repository>", "Repository of the service").option("-w, --workspaces <workspaces...>", "Workspaces of the service").option("-b, --branch <branch>", "Branch of the service").option(
+  "-e, --exclude-periods <excludePeriods...>",
+  "Periods to exclude from the service"
+).action(
+  (repository, options) => {
+    void add(
+      repository,
+      options.workspaces,
+      options.branch,
+      options.excludePeriods
+    );
+  }
+);
+program.command("install").action(install);
+program.command("update").description("Update the endpoint files").argument("<alias>", "Alias of the service to update").action(update);
+program.parse();

package/package.json

@@ -1,15 +1,38 @@
 {
   "name": "endpoints-sdk-cli",
+  "description": "endpoints sdk cli",
+  "version": "3.0.0",
+  "type": "module",
   "author": "hrdtbs",
-  "version": "3.0.0-alpha-2.0",
-  "main": "binary.js",
+  "bin": {
+    "mes": "./dist/index.cjs"
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "postinstall": "node ./install.js"
+    "test": "vitest",
+    "lint": "eslint .",
+    "postlint": "prettier --check .",
+    "format": "eslint . --fix",
+    "postformat": "prettier --write .",
+    "coverage": "vitest --coverage",
+    "build": "tsup src/index.ts --out-dir dist",
+    "typecheck": "tsc --noEmit"
   },
-  "bin": {
-    "mes": "./run.js"
+  "devDependencies": {
+    "@types/node": "22.7.8",
+    "@vitest/coverage-v8": "2.1.3",
+    "eslint": "9.17.0",
+    "eslint-config-matsuri": "5.4.0",
+    "prettier": "3.4.2",
+    "tsup": "8.4.0",
+    "typescript": "^5.6.3",
+    "vitest": "2.1.9"
   },
   "dependencies": {
-    "binary-install": "^1.0.1"
+    "@apidevtools/json-schema-ref-parser": "11.7.3",
+    "commander": "12.1.0",
+    "json-schema-to-typescript": "15.0.3"
   }
 }

package/binary.js

@@ -1,56 +0,0 @@
-const { Binary } = require("binary-install");
-const os = require("os");
-
-const windows = "x86_64-pc-windows-msvc";
-
-const getPlatform = () => {
-  const type = os.type();
-  const arch = os.arch();
-
-  // https://github.com/nodejs/node/blob/c3664227a83cf009e9a2e1ddeadbd09c14ae466f/deps/uv/src/win/util.c#L1566-L1573
-  if (
-    (type === "Windows_NT" || type.startsWith("MINGW32_NT-")) &&
-    arch === "x64"
-  ) {
-    return windows;
-  }
-  if (type === "Linux" && arch === "x64") {
-    return "x86_64-unknown-linux-musl";
-  }
-  if (type === "Linux" && arch === "arm64") {
-    return "aarch64-unknown-linux-musl";
-  }
-  if (type === "Darwin" && (arch === "x64" || arch === "arm64")) {
-    return "x86_64-apple-darwin";
-  }
-
-  throw new Error(`Unsupported platform: ${type} ${arch}`);
-};
-
-const getBinary = () => {
-  const platform = getPlatform();
-  const pkg = require("./package.json");
-  const version = pkg.version;
-  const org = "matsuri-tech";
-  const name = pkg.name;
-  const url = `https://github.com/${org}/${name}/releases/download/v${version}/${name}-v${version}-${platform}.tar.gz`;
-  return new Binary(
-    platform === windows ? "literate-disco.exe" : "literate-disco",
-    url
-  );
-};
-
-const install = () => {
-  const binary = getBinary();
-  binary.install();
-};
-
-const run = () => {
-  const binary = getBinary();
-  binary.run();
-};
-
-module.exports = {
-  install,
-  run,
-};

package/install.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-
-const { install } = require("./binary");
-install();

package/run.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-
-const { run } = require("./binary");
-run();