@osdk/cli 0.24.0-beta.13 → 0.24.0-beta.15

package/build/esm/index.js

@@ -1,17 +1,598 @@
-/*
- * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-export { cli } from "./cli.js";
+import { getYargsBase, ExitProcessError, YargsCheckError, isValidSemver } from './chunk-Q2H7XAS4.js';
+import { init_esm_shims } from './chunk-DAYFZSC6.js';
+import { consola } from 'consola';
+import { promises } from 'fs';
+import { extname } from 'path';
+
+// src/index.ts
+init_esm_shims();
+
+// src/cli.ts
+init_esm_shims();
+
+// ../cli.cmd.typescript/build/esm/index.js
+init_esm_shims();
+
+// ../cli.cmd.typescript/build/esm/cli.js
+init_esm_shims();
+
+// ../cli.cmd.typescript/build/esm/generate/generate.js
+init_esm_shims();
+var generateCommand = {
+  command: "generate",
+  describe: "Generate TypeScript SDK from ontology",
+  builder: (argv) => {
+    return argv.options({
+      outDir: {
+        type: "string",
+        description: "Where to place the generated files",
+        demandOption: true
+      },
+      ontologyPath: {
+        description: "Path to the ontology wire json",
+        type: "string",
+        demandOption: false,
+        conflicts: ["foundryUrl", "clientId"]
+      },
+      foundryUrl: {
+        description: "URL for the foundry stack that contains the ontology",
+        type: "string",
+        demandOption: false,
+        conflicts: "ontologyPath",
+        implies: "clientId",
+        alias: "stack"
+        // for backwards compatibility
+      },
+      clientId: {
+        description: "OAuth client ID for application",
+        type: "string",
+        demandOption: false,
+        conflicts: "ontologyPath",
+        implies: "foundryUrl"
+      },
+      ontologyRid: {
+        description: "Limit requests to this ontology rid only",
+        type: "string",
+        demandOption: false
+      },
+      ontologyWritePath: {
+        description: "Path to write the ontology wire json",
+        type: "string",
+        demandOption: false,
+        conflicts: ["ontologyPath"]
+      },
+      beta: {
+        type: "boolean",
+        description: "Should generate beta sdk",
+        demandOption: false
+      },
+      packageType: {
+        default: "commonjs",
+        choices: ["commonjs", "module"]
+      },
+      version: {
+        type: "string",
+        description: "Version of the generated code, or 'dev'",
+        demandOption: true
+      },
+      packageName: {
+        type: "string",
+        description: "Name of the package to generate"
+      },
+      asPackage: {
+        type: "boolean",
+        description: "Generate as a package (makes a package.json and co)"
+      },
+      clean: {
+        type: "boolean",
+        description: "Clean the output directory before generating"
+      },
+      internal: {
+        type: "boolean",
+        default: false
+      },
+      ontologyApiNamespace: {
+        type: "string"
+      },
+      apiNamespaceMap: {
+        type: "string",
+        coerce: (value) => {
+          const map = /* @__PURE__ */ new Map();
+          if (value) {
+            for (const entry of value.split(",")) {
+              const [api, ns] = entry.split(":");
+              map.set(api, ns);
+            }
+          }
+          return map;
+        },
+        default: ""
+      }
+    }).group(["ontologyPath", "outDir", "version"], "Generate from a local file").group(["foundryUrl", "clientId", "outDir", "ontologyWritePath", "version"], "OR Generate from Foundry").group(["packageName", "as"], "Package generation options").check((args) => {
+      if (!args.ontologyPath && !args.foundryUrl) {
+        throw new YargsCheckError("Must specify either ontologyPath or foundryUrl and clientId");
+      }
+      if (args.version !== "dev" && !isValidSemver(args.version)) {
+        throw new YargsCheckError("Version must be 'dev' or a valid semver version");
+      }
+      if (args.asPackage && !args.packageName) {
+        throw new YargsCheckError("Must specify packageName when generating as a package");
+      }
+      if (args.asPackage && !args.version) {
+        throw new YargsCheckError("Must specify version when generating as a package");
+      }
+      return true;
+    });
+  },
+  handler: async (args) => {
+    const command10 = await import('./handleGenerate-QM7NMLCK.js');
+    await command10.handleGenerate(args);
+  }
+};
+
+// ../cli.cmd.typescript/build/esm/typescriptCommand.js
+init_esm_shims();
+var typescriptCommand = {
+  command: "typescript",
+  describe: "Manage code",
+  builder: (argv) => {
+    return argv.command(generateCommand).demandCommand();
+  },
+  handler: async () => {
+  }
+};
+
+// src/commands/auth/index.ts
+init_esm_shims();
+
+// src/commands/auth/login/index.ts
+init_esm_shims();
+var command = {
+  command: "login",
+  describe: "Authenticate with an application ID",
+  builder: (argv) => {
+    return argv.option("clientId", {
+      alias: "applicationId",
+      // for backwards compatibility
+      type: "string",
+      demandOption: true,
+      describe: "OAuth client ID for application"
+    });
+  },
+  handler: async (args) => {
+    const command10 = await import('./loginFlow-622FU6FR.js');
+    await command10.default(args);
+  }
+};
+var login_default = command;
+
+// src/commands/auth/index.ts
+var auth = {
+  command: "auth",
+  describe: "Manage your session",
+  builder: (argv) => {
+    return argv.options({
+      foundryUrl: {
+        type: "string",
+        demandOption: true,
+        alias: "baseUrl",
+        // for backwards compatibility
+        describe: "URL for the Foundry stack"
+      }
+    }).command(login_default).demandCommand();
+  },
+  handler: async (args) => {
+  }
+};
+var auth_default = auth;
+
+// src/commands/site/index.ts
+init_esm_shims();
+
+// src/util/configLoader.ts
+init_esm_shims();
+
+// src/util/config.ts
+init_esm_shims();
+var CONFIG_FILE_NAMES = ["foundry.config.json"];
+var CONFIG_FILE_SCHEMA = {
+  type: "object",
+  properties: {
+    foundryUrl: {
+      type: "string"
+    },
+    site: {
+      type: "object",
+      properties: {
+        application: {
+          type: "string"
+        },
+        directory: {
+          type: "string"
+        },
+        autoVersion: {
+          type: "object",
+          nullable: true,
+          oneOf: [{
+            properties: {
+              type: {
+                const: "git-describe",
+                type: "string"
+              },
+              tagPrefix: {
+                type: "string",
+                nullable: true
+              }
+            }
+          }],
+          required: ["type"]
+        }
+      },
+      required: ["application", "directory"]
+    }
+  },
+  required: ["foundryUrl", "site"],
+  additionalProperties: false
+};
+async function loadFoundryConfig() {
+  const ajvModule = await import('ajv');
+  const Ajv = ajvModule.default.default;
+  const ajv = new Ajv({
+    allErrors: true
+  });
+  const validate = ajv.compile(CONFIG_FILE_SCHEMA);
+  const {
+    findUp
+  } = await import('find-up');
+  const configFilePath = await findUp(CONFIG_FILE_NAMES);
+  if (configFilePath) {
+    let foundryConfig;
+    try {
+      const fileContent = await promises.readFile(configFilePath, "utf-8");
+      foundryConfig = parseConfigFile(fileContent, configFilePath);
+    } catch (error) {
+      throw new ExitProcessError(2, `Couldn't read or parse config file ${configFilePath}. Error: ${error}`);
+    }
+    if (!validate(foundryConfig)) {
+      throw new ExitProcessError(2, `The configuration file does not match the expected schema: ${ajv.errorsText(validate.errors)}`);
+    }
+    return {
+      foundryConfig,
+      configFilePath
+    };
+  }
+  return void 0;
+}
+function parseConfigFile(fileContent, configFilePath) {
+  const extension = extname(configFilePath);
+  switch (extension) {
+    case ".json":
+      return JSON.parse(fileContent);
+    default:
+      throw new ExitProcessError(2, `Unsupported file extension: ${extension} for config file.`);
+  }
+}
+
+// src/util/configLoader.ts
+var configPromise = void 0;
+function getConfig() {
+  if (configPromise == null) {
+    configPromise = loadFoundryConfig();
+  }
+  return configPromise;
+}
+var configLoader_default = getConfig;
+
+// src/commands/site/deploy/index.ts
+init_esm_shims();
+
+// src/commands/site/deploy/logDeployCommandConfigFileOverride.ts
+init_esm_shims();
+async function logDeployCommandConfigFileOverride(args, config) {
+  if (config?.autoVersion != null && args.autoVersion !== config?.autoVersion.type) {
+    consola.debug(`Overriding "autoVersion" from config file with ${args.autoVersion}`);
+  }
+  if (config?.directory != null && args.directory !== config?.directory) {
+    consola.debug(`Overriding "directory" from config file with ${args.directory}`);
+  }
+  if (config?.autoVersion?.tagPrefix != null && args.gitTagPrefix != null && args.gitTagPrefix !== config?.autoVersion.tagPrefix) {
+    consola.debug(`Overriding "gitTagPrefix" from config file with ${args.gitTagPrefix}`);
+  }
+}
+
+// src/commands/site/deploy/index.ts
+var command2 = {
+  command: "deploy",
+  describe: "Deploy a new site version",
+  builder: async (argv) => {
+    const config = await configLoader_default();
+    const siteConfig = config?.foundryConfig.site;
+    const directory = siteConfig?.directory;
+    const autoVersion = siteConfig?.autoVersion;
+    const gitTagPrefix = autoVersion?.tagPrefix;
+    return argv.options({
+      directory: {
+        type: "string",
+        description: "Directory containing site files",
+        ...directory ? {
+          default: directory
+        } : {
+          demandOption: true
+        }
+      },
+      uploadOnly: {
+        type: "boolean",
+        description: "Upload new site version only without setting as live",
+        default: false
+      },
+      version: {
+        type: "string",
+        description: "New version of site to deploy",
+        ...autoVersion == null ? {
+          conflicts: "autoVersion"
+        } : {}
+      },
+      autoVersion: {
+        coerce: (autoVersion2) => autoVersion2,
+        type: "string",
+        choices: ["git-describe"],
+        description: "Enable auto versioning",
+        ...autoVersion != null ? {
+          default: autoVersion.type
+        } : {
+          conflicts: "version"
+        }
+      },
+      gitTagPrefix: {
+        type: "string",
+        description: "Prefix to match git tags on when 'git-describe' auto versioning is used. If not provided, all tags are matched and the prefix 'v' is stripped if present.",
+        ...gitTagPrefix ? {
+          default: gitTagPrefix
+        } : {}
+      }
+    }).group(["directory", "version", "uploadOnly"], "Deploy Options").group(["autoVersion", "gitTagPrefix"], "Auto Version Options").check((args) => {
+      if (autoVersion == null && args.autoVersion == null && args.version == null) {
+        throw new YargsCheckError("One of --version or --autoVersion must be specified");
+      }
+      if (args.version != null && !isValidSemver(args.version)) {
+        throw new YargsCheckError(`--version "${args.version}" must be a valid SemVer string`);
+      }
+      const autoVersionType = args.autoVersion ?? autoVersion;
+      if (autoVersionType !== "git-describe") {
+        throw new YargsCheckError(`Only 'git-describe' is supported for autoVersion`);
+      }
+      const gitTagPrefixValue = args.gitTagPrefix ?? gitTagPrefix;
+      if (gitTagPrefixValue != null && autoVersionType !== "git-describe") {
+        throw new YargsCheckError(`--gitTagPrefix is only supported when --autoVersion=git-describe`);
+      }
+      return true;
+    }).middleware((args) => logDeployCommandConfigFileOverride(args, siteConfig));
+  },
+  handler: async (args) => {
+    const command10 = await import('./siteDeployCommand-TPTNUT5R.js');
+    const {
+      version,
+      autoVersion,
+      gitTagPrefix,
+      ...restArgs
+    } = args;
+    const selectedVersion = args.version != null ? args.version : {
+      type: args.autoVersion,
+      tagPrefix: args.gitTagPrefix
+    };
+    await command10.default({
+      ...restArgs,
+      selectedVersion
+    });
+  }
+};
+var deploy_default = command2;
+
+// src/commands/site/logSiteCommandConfigFileOverride.ts
+init_esm_shims();
+async function logSiteCommandConfigFileOverride(args, config) {
+  if (config?.site.application != null && args.application !== config.site.application) {
+    consola.debug(`Overriding "application" from config file with ${args.application}`);
+  }
+  if (config?.foundryUrl != null && args.foundryUrl !== config.foundryUrl) {
+    consola.debug(`Overriding "foundryUrl" from config file with ${args.foundryUrl}`);
+  }
+}
+
+// src/commands/site/version/index.ts
+init_esm_shims();
+
+// src/commands/site/version/delete/index.ts
+init_esm_shims();
+var command3 = {
+  command: "delete <version>",
+  describe: "Delete site version",
+  builder: (argv) => {
+    return argv.positional("version", {
+      type: "string",
+      demandOption: true,
+      description: "Version to set as live"
+    }).option("yes", {
+      alias: "y",
+      type: "boolean",
+      description: "Automatically confirm destructive changes"
+    }).group(["yes"], "Delete Options");
+  },
+  handler: async (args) => {
+    const command10 = await import('./versionDeleteCommand-LBZGRIYN.js');
+    await command10.default(args);
+  }
+};
+var delete_default = command3;
+
+// src/commands/site/version/get/index.ts
+init_esm_shims();
+var command4 = {
+  command: "get",
+  describe: "Get live site version",
+  builder: (argv) => {
+    return argv;
+  },
+  handler: async (args) => {
+    const command10 = await import('./versionGetCommand-BJ3QWAHL.js');
+    await command10.default(args);
+  }
+};
+var get_default = command4;
+
+// src/commands/site/version/list/index.ts
+init_esm_shims();
+var command5 = {
+  command: "list",
+  describe: "List site versions",
+  builder: (argv) => {
+    return argv;
+  },
+  handler: async (args) => {
+    const command10 = await import('./versionListCommand-P7OMJYES.js');
+    await command10.default(args);
+  }
+};
+var list_default = command5;
+
+// src/commands/site/version/set/index.ts
+init_esm_shims();
+var command6 = {
+  command: "set <version>",
+  describe: "Set live site version",
+  builder: (argv) => {
+    return argv.positional("version", {
+      type: "string",
+      demandOption: true,
+      description: "Version to set as live"
+    });
+  },
+  handler: async (args) => {
+    const command10 = await import('./versionSetCommand-N3PA4HYH.js');
+    await command10.default(args);
+  }
+};
+var set_default = command6;
+
+// src/commands/site/version/unset/index.ts
+init_esm_shims();
+var command7 = {
+  command: "unset",
+  describe: "Clear live site version",
+  builder: (argv) => {
+    return argv.option("yes", {
+      alias: "y",
+      type: "boolean",
+      description: "Automatically confirm destructive changes"
+    }).group(["yes"], "Unset Options");
+  },
+  handler: async (args) => {
+    const command10 = await import('./versionUnsetCommand-AD426TBT.js');
+    await command10.default(args);
+  }
+};
+var unset_default = command7;
+
+// src/commands/site/version/index.ts
+var command8 = {
+  command: "version",
+  describe: "Manage site versions",
+  builder: (argv) => {
+    return argv.command(list_default).command(get_default).command(set_default).command(unset_default).command(delete_default).demandCommand();
+  },
+  handler: async (args) => {
+  }
+};
+var version_default = command8;
+
+// src/commands/site/index.ts
+var command9 = {
+  command: "site",
+  describe: "Manage your site",
+  builder: async (argv) => {
+    const config = await configLoader_default();
+    const application = config?.foundryConfig.site.application;
+    const foundryUrl = config?.foundryConfig.foundryUrl;
+    return argv.options({
+      application: {
+        type: "string",
+        coerce: (application2) => application2,
+        ...application ? {
+          default: application
+        } : {
+          demandOption: true
+        },
+        description: "Application resource identifier (rid)"
+      },
+      foundryUrl: {
+        coerce: (foundryUrl2) => foundryUrl2.replace(/\/$/, ""),
+        type: "string",
+        ...foundryUrl ? {
+          default: foundryUrl
+        } : {
+          demandOption: true
+        },
+        description: "URL for the Foundry stack"
+      },
+      token: {
+        type: "string",
+        conflicts: "tokenFile",
+        description: "Foundry API token"
+      },
+      tokenFile: {
+        type: "string",
+        conflicts: "token",
+        description: "Path to file containing Foundry API token"
+      }
+    }).group(["application", "foundryUrl", "token", "tokenFile"], "Common Options").command(version_default).command(deploy_default).check((args) => {
+      if (!args.foundryUrl.startsWith("https://")) {
+        throw new YargsCheckError("foundryUrl must start with https://");
+      }
+      return true;
+    }).middleware((args) => logSiteCommandConfigFileOverride(args, config?.foundryConfig)).demandCommand();
+  },
+  handler: async (args) => {
+  }
+};
+var site_default = command9;
+
+// src/yargs/logConfigFileMiddleware.ts
+init_esm_shims();
+var firstTime = true;
+async function logConfigFileMiddleware() {
+  if (firstTime) {
+    firstTime = false;
+    const config = configLoader_default();
+    const configFilePath = (await config)?.configFilePath;
+    if (configFilePath) {
+      consola.debug(`Using configuration from file: "${configFilePath}"`);
+    }
+  }
+}
+
+// src/cli.ts
+async function cli2(args = process.argv) {
+  consola.info(`Palantir OSDK CLI ${"0.24.0-beta.15"}
+`);
+  const base = getYargsBase(args);
+  try {
+    return await base.middleware(logConfigFileMiddleware).command(site_default).command({
+      command: "unstable",
+      aliases: ["experimental"],
+      describe: "Unstable commands",
+      builder: async (argv) => {
+        return argv.command(typescriptCommand).command(auth_default).demandCommand();
+      },
+      handler: (_args) => {
+      }
+    }).parseAsync();
+  } catch (err) {
+    if (err instanceof ExitProcessError) {
+      consola.error(err);
+    }
+  }
+}
+
+export { cli2 as cli };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map