@osdk/cli 0.3.0 → 0.5.0

package/build/js/index.mjs

@@ -1,7 +1,10 @@
+import { isValidSemver } from './chunk-N6K26UR4.mjs';
 import { ExitProcessError } from './chunk-GTNZA5UY.mjs';
 import './chunk-E2SEJZTC.mjs';
+import { consola } from 'consola';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import { promises } from 'fs';
 
 // src/commands/auth/login/index.ts
 var command = {
@@ -14,8 +17,8 @@ var command = {
     });
   },
   handler: async (args) => {
-    const command7 = await import('./loginFlow-KGLTXVZ6.mjs');
-    await command7.default(args);
+    const command11 = await import('./loginFlow-KGLTXVZ6.mjs');
+    await command11.default(args);
   }
 };
 var login_default = command;
@@ -36,118 +39,325 @@ var site = {
   }
 };
 var auth_default = site;
-
-// src/commands/site/delete/index.ts
-var command2 = {
-  command: "delete",
-  describe: "Delete an uploaded version",
-  builder: (argv) => {
-    return argv.option("siteVersion", {
-      type: "string",
-      demandOption: true
-    }).option("dir", {
+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"]
+    }
   },
-  handler: async (args) => {
-    const command7 = await import('./siteDeleteCommand-47GMSHFS.mjs');
-    await command7.default(args);
+  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 = JSON.parse(fileContent);
+    } catch {
+      throw new ExitProcessError(2, `Couldn't read or parse config file ${configFilePath}`);
+    }
+    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;
+}
+
+// src/util/configLoader.ts
+var configPromise = void 0;
+function getConfig() {
+  if (configPromise == null) {
+    configPromise = loadFoundryConfig();
+  }
+  return configPromise;
+}
+var configLoader_default = getConfig;
+
+// src/YargsCheckError.ts
+var YargsCheckError = class extends Error {
+  constructor(msg) {
+    super(msg);
   }
 };
-var delete_default = command2;
+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 command3 = {
+var command2 = {
   command: "deploy",
   describe: "Deploy an uploaded version",
-  builder: (argv) => {
+  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({
-      "siteVersion": {
+      directory: {
         type: "string",
-        conflicts: "clearVersion"
-        // group: "Deploy Version",
-        // implies: { "clearVersion": "false" },
+        description: "Directory to deploy",
+        ...directory ? {
+          default: directory
+        } : {
+          demandOption: true
+        }
       },
-      undeploy: {
-        alias: "clearVersion",
-        description: "Causes the site to no longer be deployed",
+      uploadOnly: {
         type: "boolean",
-        conflicts: "siteVersion"
-        // group: "Deploy Version",
-        // implies: { "siteVersion": "" },
+        description: "Upload the directory but do not deploy it",
+        default: false
+      },
+      version: {
+        type: "string",
+        description: "Version to deploy",
+        ...autoVersion == null ? {
+          conflicts: "autoVersion"
+        } : {}
+      },
+      autoVersion: {
+        type: "string",
+        description: "Enables autoversioning. Can be set to 'git-describe' to use git describe to determine the version.",
+        ...autoVersion != null ? {
+          default: autoVersion.type
+        } : {
+          conflicts: "version"
+        }
+      },
+      gitTagPrefix: {
+        type: "string",
+        description: "Prefix to match git tags against when --autoVersion=git-describe is used. If not provided, a default prefix 'v' is used.",
+        ...gitTagPrefix ? {
+          default: gitTagPrefix
+        } : {}
+      }
+    }).group(["autoVersion", "gitTagPrefix"], "Autoversion Arguments").group(["version", "directory", "uploadOnly"], "Common Arguments").check((args) => {
+      if (autoVersion == null && args.autoVersion == null && args.version == null) {
+        throw new YargsCheckError("One of --version or --autoVersion must be specified");
       }
-    }).group(["siteVersion", "clearVersion"], "Version To Deploy (requires one of)");
+      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 command7 = await import('./handleSiteDeploy-HHXON5YE.mjs');
-    await command7.default(args);
+    const command11 = await import('./siteDeployCommand-7GXJF5HF.mjs');
+    await command11.default(args);
   }
 };
-var deploy_default = command3;
+var deploy_default = command2;
+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/upload/index.ts
-var command4 = {
-  command: "upload",
-  describe: "Upload an application version",
+// src/commands/site/version/delete/index.ts
+var command3 = {
+  command: "delete <version>",
+  describe: "Delete the specified site version.",
   builder: (argv) => {
-    return argv.option("siteVersion", {
+    return argv.positional("version", {
       type: "string",
-      demandOption: true
-    }).option("dir", {
-      type: "string"
+      demandOption: true,
+      description: "Version to set as live"
     });
   },
   handler: async (args) => {
-    const command7 = await import('./siteUploadCommand-S2HTCGZK.mjs');
-    await command7.default(args);
+    const command11 = await import('./versionDeleteCommand-6BJL5XLG.mjs');
+    await command11.default(args);
   }
 };
-var upload_default = command4;
+var delete_default = command3;
 
-// src/commands/site/versions/index.ts
+// src/commands/site/version/get/index.ts
+var command4 = {
+  command: "get",
+  describe: "Get the currently set live site version",
+  builder: (argv) => {
+    return argv;
+  },
+  handler: async (args) => {
+    const command11 = await import('./versionGetCommand-OR4RLOLM.mjs');
+    await command11.default(args);
+  }
+};
+var get_default = command4;
+
+// src/commands/site/version/list/index.ts
 var command5 = {
-  command: "versions",
+  command: "list",
   describe: "List application versions",
   builder: (argv) => {
     return argv;
   },
   handler: async (args) => {
-    const command7 = await import('./siteVersionsCommand-X5MO726Z.mjs');
-    await command7.default(args);
+    const command11 = await import('./versionListCommand-LPPGQCQF.mjs');
+    await command11.default(args);
+  }
+};
+var list_default = command5;
+
+// src/commands/site/version/set/index.ts
+var command6 = {
+  command: "set <version>",
+  describe: "Set the live site version",
+  builder: (argv) => {
+    return argv.positional("version", {
+      type: "string",
+      demandOption: true,
+      description: "Version to set as live"
+    });
+  },
+  handler: async (args) => {
+    const command11 = await import('./versionSetCommand-LHOVVI6U.mjs');
+    await command11.default(args);
+  }
+};
+var set_default = command6;
+
+// src/commands/site/version/unset/index.ts
+var command7 = {
+  command: "unset",
+  describe: "Clear the currently set live site version.",
+  builder: (argv) => {
+    return argv;
+  },
+  handler: async (args) => {
+    const command11 = await import('./versionUnsetCommand-IJT4JWBN.mjs');
+    await command11.default(args);
+  }
+};
+var unset_default = command7;
+
+// src/commands/site/version/index.ts
+var command8 = {
+  command: "version",
+  describe: "Manage application version",
+  builder: (argv) => {
+    return argv.command(list_default).command(set_default).command(unset_default).command(delete_default).command(get_default).demandCommand();
+  },
+  handler: async (args) => {
   }
 };
-var versions_default = command5;
+var version_default = command8;
 
 // src/commands/site/index.ts
-var site2 = {
+var command9 = {
   command: "site",
   describe: "Manage your site",
-  builder: (argv) => {
+  builder: async (argv) => {
+    const config = await configLoader_default();
+    const application = config?.foundryConfig.site.application;
+    const foundryUrl = config?.foundryConfig.foundryUrl;
     return argv.options({
-      appRid: {
+      application: {
         type: "string",
-        demandOption: true,
-        coerce: (a) => a
+        coerce: (application2) => application2,
+        ...application ? {
+          default: application
+        } : {
+          demandOption: true
+        },
+        description: "Application RID"
       },
-      baseUrl: {
+      foundryUrl: {
+        coerce: (foundryUrl2) => foundryUrl2.replace(/\/$/, ""),
         type: "string",
-        demandOption: true
+        ...foundryUrl ? {
+          default: foundryUrl
+        } : {
+          demandOption: true
+        },
+        description: "Foundry Stack URL with Protocol (e.g. https://example.palantirfoundry.com)"
+      },
+      token: {
+        type: "string",
+        conflicts: "tokenFile",
+        description: "Foundry API Token"
+      },
+      tokenFile: {
+        type: "string",
+        conflicts: "token",
+        description: "Path to a file containing your Foundry API Token"
+      }
+    }).group(["application", "foundryUrl", "token", "tokenFile"], "Common Arguments").command(version_default).command(deploy_default).check((args) => {
+      if (!args.foundryUrl.startsWith("https://")) {
+        throw new YargsCheckError("foundryUrl must start with https://");
       }
-    }).group(["appRid", "baseUrl"], "Common Arguments").command(versions_default).command(upload_default).command(delete_default).command(deploy_default).demandCommand();
+      return true;
+    }).middleware((args) => logSiteCommandConfigFileOverride(args, config?.foundryConfig)).demandCommand();
   },
   handler: async (args) => {
   }
 };
-var site_default = site2;
-
-// src/util/isValidSemver.ts
-var semver = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
-function isValidSemver(semverString) {
-  return semver.test(semverString);
-}
+var site_default = command9;
 
 // src/commands/typescript/generate/generate.ts
-var command6 = {
+var command10 = {
   command: "generate",
   describe: "Generate typescript from ontology",
   builder: (argv) => {
@@ -197,25 +407,25 @@ var command6 = {
         description: "Version of the generated code, or 'dev'",
         demandOption: true
       }
-    }).group(["ontologyPath", "outDir", "version"], "Generate from a local file").group(["stack", "clientId", "outDir", "ontologyWritePath", "version"], "OR Generate from a stack").check((argv2) => {
-      if (!argv2.ontologyPath && !argv2.stack) {
+    }).group(["ontologyPath", "outDir", "version"], "Generate from a local file").group(["stack", "clientId", "outDir", "ontologyWritePath", "version"], "OR Generate from a stack").check((args) => {
+      if (!args.ontologyPath && !args.stack) {
         throw new Error("Error: Must specify either ontologyPath or stack and clientId");
       }
-      if (argv2.version !== "dev" && !isValidSemver(argv2.version)) {
+      if (args.version !== "dev" && !isValidSemver(args.version)) {
         throw new Error("Error: Version must be 'dev' or a valid semver version");
       }
       return true;
     });
   },
   handler: async (args) => {
-    const command7 = await import('./handleGenerate-K6X2HG4V.mjs');
-    await command7.default(args);
+    const command11 = await import('./handleGenerate-ZUZV3IBI.mjs');
+    await command11.default(args);
   }
 };
-var generate_default = command6;
+var generate_default = command10;
 
 // src/commands/typescript/index.ts
-var site3 = {
+var site2 = {
   command: "typescript",
   describe: "Manage code",
   builder: (argv) => {
@@ -224,46 +434,67 @@ var site3 = {
   handler: async (args) => {
   }
 };
-var typescript_default = site3;
-
-// src/yargs/logVersionMiddleware.ts
+var typescript_default = site2;
 var firstTime = true;
-async function logVersionMiddleware(args) {
+async function logConfigFileMiddleware() {
   if (firstTime) {
-    const Consola = await import('consola');
-    const consola = Consola.consola;
-    consola.info(`Palantir OSDK CLI ${"0.3.0"}`);
+    firstTime = false;
+    const config = configLoader_default();
+    const configFilePath = (await config)?.configFilePath;
+    if (configFilePath) {
+      consola.debug(`Using configuration from file: "${configFilePath}"`);
+    }
+  }
+}
+var firstTime2 = true;
+async function logVersionMiddleware(args) {
+  if (firstTime2) {
+    firstTime2 = false;
+    consola.info(`Palantir OSDK CLI ${"0.5.0"}`);
     consola.level = 3 + args.verbose;
     if (consola.level > 3) {
       consola.debug(`Verbose logging enabled (${consola.level === 4 ? "debug" : "trace"})`);
     }
-    console.log();
-    firstTime = false;
+    consola.log("");
   }
 }
 
 // src/cli.ts
 async function cli(args = process.argv) {
-  const base = yargs(hideBin(args)).env("OSDK").version(false).option("verbose", {
+  const base = yargs(hideBin(args)).wrap(Math.min(150, yargs().terminalWidth())).env("OSDK").version(false).option("verbose", {
     alias: "v",
     type: "boolean",
     description: "Enable verbose logging",
     count: true
-  }).demandCommand().middleware(logVersionMiddleware, true).strict().command({
+  }).demandCommand().middleware(logVersionMiddleware, true).middleware(logConfigFileMiddleware).strict().command({
     command: "unstable",
     aliases: ["experimental"],
+    describe: "Unstable commands",
     builder: async (argv) => {
       return argv.command(site_default).command(typescript_default).command(auth_default).demandCommand();
     },
     handler: (_args) => {
     }
+  }).fail(async (msg, err, argv) => {
+    if (err instanceof ExitProcessError) {
+      consola.error(err.message);
+      consola.debug(err.stack);
+    } else {
+      if (err && err instanceof YargsCheckError === false) {
+        throw err;
+      } else {
+        argv.showHelp();
+        consola.log("");
+        consola.error(msg);
+      }
+    }
+    process.exit(1);
   });
   try {
-    return base.parseAsync();
-  } catch (e) {
-    if (e instanceof ExitProcessError) {
-      const Consola = await import('consola');
-      Consola.consola.error(e.message);
+    return await base.parseAsync();
+  } catch (err) {
+    if (err instanceof ExitProcessError) {
+      consola.error(err);
     }
   }
 }