@takeshape/cli 9.14.0 → 9.15.0

package/dist/commands/import/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _projectImport = _interopRequireDefault(require("./project-import"));
+
+var _schemaImport = _interopRequireDefault(require("./schema-import"));
+
+var _rolesImport = _interopRequireDefault(require("./roles-import"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const commandHandler = async (cli, params) => {
+  const {
+    flags
+  } = cli;
+
+  if (flags.schema) {
+    return (0, _schemaImport.default)(cli, params);
+  }
+
+  if (flags.roles) {
+    return (0, _rolesImport.default)(cli, params);
+  }
+
+  return (0, _projectImport.default)(cli, params);
+};
+
+var _default = commandHandler;
+exports.default = _default;

package/dist/commands/import/project-import.d.ts

@@ -0,0 +1,11 @@
+type ImportStrategy = 'uri' | 'zip' | 'dir';
+export interface ProjectImport {
+    id: string;
+    status: string;
+    message: string;
+    projectId: string;
+}
+export declare function determineImportStrategy(path: string): Promise<ImportStrategy>;
+declare const _default: import("../../types").Handler;
+export default _default;
+//# sourceMappingURL=project-import.d.ts.map

package/dist/commands/import/project-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-import.d.ts","sourceRoot":"","sources":["../../../../src/commands/import/project-import.ts"],"names":[],"mappings":"AAaA,KAAK,cAAc,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAW5C,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AA4BD,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAenF;;AAyCD,wBAmDG"}

package/dist/commands/import/project-import.js

@@ -0,0 +1,198 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.determineImportStrategy = determineImportStrategy;
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _path = require("path");
+
+var _archiver = _interopRequireDefault(require("archiver"));
+
+var _streams = require("@takeshape/streams");
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _log = _interopRequireDefault(require("../../log"));
+
+var _upload = require("../../util/upload");
+
+var _spin = _interopRequireDefault(require("../../util/spin"));
+
+var _graphql = require("../../graphql");
+
+var _fatalError = require("../../util/fatal-error");
+
+var _linkedCommand = require("../../util/linked-command");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var TO;
+
+(function (TO) {
+  TO["NEW_PROJECT"] = "new-project";
+  TO["CURRENT_PROJECT"] = "current-project";
+})(TO || (TO = {}));
+
+const startImport = (0, _graphql.graphQLQuery)(`
+  mutation ($uri: String!, $name: String, $projectId: String) {
+    result: tsImportProject(uri: $uri, name: $name, origin: "@takeshape/cli", projectId: $projectId)
+  }
+`);
+const getImport = (0, _graphql.graphQLQuery)(`
+  query ($importId: String!) {
+    result: tsGetProjectImport(id: $importId) {
+      id
+      status
+      message
+      projectId
+    }
+  }
+`);
+const getUploadUrl = (0, _graphql.graphQLQuery)(`
+  mutation ($filename: String!, $projectId: String) {
+    result: tsUploadProject(name: $filename, type: "application/zip", origin: "@takeshape/cli", projectId: $projectId) {
+      uri
+      importId
+    }
+  }
+`);
+
+async function determineImportStrategy(path) {
+  if (/^https?:\/\/.*/.exec(path) !== null) {
+    return 'uri';
+  }
+
+  if (/\.zip$/.exec(path) !== null) {
+    return 'zip';
+  }
+
+  await _fsExtra.default.access(path);
+
+  if (_fsExtra.default.statSync(path).isDirectory()) {
+    return 'dir';
+  }
+
+  throw Error('Unrecognized import path provided. Please provide a URI, zip path, or directory path');
+}
+
+function getTo(to) {
+  if (to === undefined) {
+    return TO.NEW_PROJECT;
+  }
+
+  if (Object.values(TO).includes(to)) {
+    return to;
+  }
+
+  throw new Error(`Invalid "to" param. Was ${to}, must be one of: ${Object.values(TO).join(', ')}`);
+}
+
+async function listenForImportSuccess(client, importId) {
+  // Spin until we get a 'success' message or it throws an error
+  const spinQuery = getImport.bind(getImport, client, {
+    importId
+  });
+  await (0, _spin.default)(spinQuery); // Return the ID of the project created by the import
+
+  const {
+    projectId
+  } = await getImport(client, {
+    importId
+  });
+  return projectId;
+}
+
+async function uploadZipFile(client, filename, filePath, projectId) {
+  const {
+    uri,
+    importId
+  } = await getUploadUrl(client, {
+    filename,
+    projectId
+  });
+  await (0, _upload.uploadFile)(filePath, uri);
+  return importId;
+}
+/*
+Takeshape import --project
+
+Import a project from a path or URL.
+The user must be logged in.
+
+Flags:
+--from  Either a URI, zip file, or directory to import
+--name  Provides a name for the newly imported project.
+        Otherwise, the import will use the name in the pattern.yml file.
+*/
+
+
+var _default = (0, _linkedCommand.loggedInCommand)(async (cli, params) => {
+  const {
+    flags
+  } = cli; // We need to get a user token in order for the import to work
+
+  if (!flags || !flags.from) {
+    return (0, _fatalError.fatalError)('No flags provided.');
+  }
+
+  const client = (0, _graphql.createAdminConnector)(params, params.authToken);
+
+  try {
+    const {
+      from
+    } = flags;
+    const strategy = await determineImportStrategy(from);
+    const to = getTo(flags.to);
+    const projectId = to === TO.CURRENT_PROJECT ? params.projectId : undefined;
+
+    if (to === TO.CURRENT_PROJECT && projectId === undefined) {
+      throw new Error('Not currently linked to a project. Run `takeshape link` to link to a project.');
+    }
+
+    let importId;
+
+    if (strategy === 'dir') {
+      (0, _log.default)(`Zipping up ${from}…`);
+      const dirName = (0, _path.basename)(from);
+      const [zipPath] = (0, _upload.createTempFile)(`${dirName}.zip`);
+
+      const output = _fsExtra.default.createWriteStream(zipPath);
+
+      const archive = (0, _archiver.default)('zip');
+      archive.directory(from, false);
+      await archive.finalize();
+      await (0, _streams.pump)(archive, output);
+      (0, _log.default)(`Starting import from ${dirName}.zip…\n`);
+      importId = await uploadZipFile(client, `${dirName}.zip`, zipPath, projectId);
+    }
+
+    if (strategy === 'zip') {
+      (0, _log.default)(`Starting import from ${from}…\n`);
+      const fileName = (0, _path.basename)(from);
+      importId = await uploadZipFile(client, fileName, from, projectId);
+    }
+
+    if (strategy === 'uri') {
+      (0, _log.default)(`Starting import from ${from}…\n`);
+      importId = await startImport(client, {
+        uri: from,
+        name: flags.name,
+        projectId
+      });
+    }
+
+    if (importId) {
+      const resultProjectId = await listenForImportSuccess(client, importId);
+      (0, _log.default)(_chalk.default.green(`Success!`), `${projectId ? 'Updated' : 'Created'} project ${resultProjectId} from import.`);
+      process.exit(0);
+    }
+  } catch (error) {
+    return (0, _fatalError.fatalError)(error.message);
+  }
+});
+
+exports.default = _default;

package/dist/commands/import/roles-import.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../types").Handler;
+export default _default;
+//# sourceMappingURL=roles-import.d.ts.map

package/dist/commands/import/roles-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles-import.d.ts","sourceRoot":"","sources":["../../../../src/commands/import/roles-import.ts"],"names":[],"mappings":";AAUA,wBAsBG"}

package/dist/commands/import/roles-import.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _fatalError = require("../../util/fatal-error");
+
+var _linkedCommand = require("../../util/linked-command");
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _log = require("../../log");
+
+var _api = _interopRequireDefault(require("../../util/api"));
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _schema = require("@takeshape/schema");
+
+var _fs = require("../../util/fs");
+
+var _branches = require("../../util/branches");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _linkedCommand.linkedCommand)(async (cli, params) => {
+  const {
+    flags
+  } = cli;
+
+  if (!flags.from) {
+    return (0, _fatalError.fatalError)('No roles file provided. Use `--from path/to/file` or `--from directory`.');
+  }
+
+  const {
+    exists,
+    file
+  } = (0, _fs.resolveFromFlag)(flags.from, 'roles.json');
+
+  if (!exists) {
+    return (0, _fatalError.fatalError)(`Roles file does not exist: ${file}`);
+  }
+
+  const branchParams = (0, _branches.getBranchParams)(cli);
+
+  try {
+    const roles = JSON.parse(_fsExtra.default.readFileSync(file).toString());
+    const validatedRoles = (0, _schema.ensureValidRoleImport)(roles);
+    (0, _log.log)(`Uploading roles from ${file}…\n`);
+    await (0, _api.default)(params, 'POST', `${(0, _branches.getBranchBasePath)(branchParams, params.projectId)}/roles`, validatedRoles);
+    (0, _log.log)(_chalk.default.green('Success!'), 'Roles updated.');
+  } catch (e) {
+    return (0, _fatalError.fatalError)(e.message);
+  }
+});
+
+exports.default = _default;

package/dist/commands/import/schema-import.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../types").Handler;
+export default _default;
+//# sourceMappingURL=schema-import.d.ts.map

package/dist/commands/import/schema-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-import.d.ts","sourceRoot":"","sources":["../../../../src/commands/import/schema-import.ts"],"names":[],"mappings":";AAsBA,wBAuCG"}

package/dist/commands/import/schema-import.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _fatalError = require("../../util/fatal-error");
+
+var _api = _interopRequireDefault(require("../../util/api"));
+
+var _log = _interopRequireDefault(require("../../log"));
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _schema = require("@takeshape/schema");
+
+var _linkedCommand = require("../../util/linked-command");
+
+var _formatValidationResult = require("../../util/format-validation-result");
+
+var _fs = require("../../util/fs");
+
+var _branches = require("../../util/branches");
+
+var _url = require("url");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+takeshape import --schema --from ./path/to/schema.json
+
+Replace your project's schema by uploading a new one
+
+Flags:
+--from          Directory containing a schema.json or path to schema.json file
+--preserveAuth  Do not overwrite service authentication
+*/
+var _default = (0, _linkedCommand.linkedCommand)(async (cli, params) => {
+  const {
+    flags
+  } = cli;
+  const {
+    projectId
+  } = params;
+
+  if (!flags.from) {
+    return (0, _fatalError.fatalError)('No schema file provided. Use `--from path/to/file` or `--from directory`.');
+  }
+
+  const {
+    exists,
+    file
+  } = (0, _fs.resolveFromFlag)(flags.from, 'schema.json');
+
+  if (!exists) {
+    return (0, _fatalError.fatalError)(`Schema file does not exist: ${file}`);
+  }
+
+  const branchParams = (0, _branches.getBranchParams)(cli);
+  const queryParams = {
+    force: 'true'
+  };
+
+  if (flags.preserveAuth) {
+    queryParams.preserveAuth = 'true';
+  }
+
+  if (flags.tag) {
+    queryParams.tag = flags.tag;
+  }
+
+  try {
+    const newSchema = JSON.parse(_fsExtra.default.readFileSync(file).toString());
+    const validationString = (0, _formatValidationResult.formatValidationResult)((0, _schema.validateProjectSchemaImport)(newSchema));
+
+    if (validationString) {
+      return (0, _fatalError.fatalError)(validationString);
+    }
+
+    (0, _log.default)(`Uploading schema from ${file}…\n`);
+    const schemaImportPath = `${(0, _branches.getBranchBasePath)(branchParams, projectId)}/schema?${new _url.URLSearchParams(queryParams)}`;
+    const uploaded = await (0, _api.default)(params, 'POST', schemaImportPath, newSchema);
+    (0, _log.default)(_chalk.default.green('Success!'), `Schema updated to version ${uploaded.version}.`);
+    process.exit(0);
+  } catch (e) {
+    return (0, _fatalError.fatalError)(e.message);
+  }
+});
+
+exports.default = _default;

package/dist/commands/link.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../types").Handler;
+export default _default;
+//# sourceMappingURL=link.d.ts.map

package/dist/commands/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../src/commands/link.ts"],"names":[],"mappings":";AAQA,wBAkCG"}

package/dist/commands/link.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _log = _interopRequireDefault(require("../log"));
+
+var _prompt = require("../prompt");
+
+var _data = require("../util/data");
+
+var _config = require("../config");
+
+var _linkedCommand = require("../util/linked-command");
+
+var _selectProject = require("../util/select-project");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _linkedCommand.loggedInCommand)(async (_, params) => {
+  try {
+    const project = await (0, _selectProject.selectProject)(params);
+
+    if (!project) {
+      return;
+    }
+
+    const sites = await (0, _data.fetchSites)(params, project.value);
+    let site;
+
+    if (sites.length) {
+      var _site;
+
+      site = await (0, _prompt.promptList)('Select a site:', sites);
+
+      if (((_site = site) === null || _site === void 0 ? void 0 : _site.value) === 'NONE') {
+        site = undefined;
+      }
+    }
+
+    const isSameProject = params.projectId === project.value;
+    let {
+      linkedApiKey
+    } = params; // Clean up old API key
+
+    if (!isSameProject && params.linkedApiKey && params.projectId) {
+      await (0, _data.deleteApiKey)(params, params.projectId, params.linkedApiKey.id);
+    } // Only create a new API key if project has changed
+
+
+    if (!isSameProject || !linkedApiKey) {
+      linkedApiKey = await (0, _data.createReadOnlyApiKey)(params, project.value);
+    }
+
+    await (0, _config.writeLinkedProjectConfig)(params, linkedApiKey, project, site);
+  } catch (e) {
+    (0, _log.default)(e);
+  }
+});
+
+exports.default = _default;

package/dist/commands/login.d.ts

@@ -0,0 +1,4 @@
+import { Handler } from '../types';
+declare const login: Handler;
+export default login;
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../src/commands/login.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAC,MAAM,UAAU,CAAC;AAIjC,QAAA,MAAM,KAAK,EAAE,OAWZ,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/commands/login.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _log = _interopRequireDefault(require("../log"));
+
+var _login = require("../util/login");
+
+var _config = require("../config");
+
+var _data = require("../util/data");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const login = async (_, params) => {
+  try {
+    const userJwt = await (params.cliLogin ? (0, _login.loginCli)(params, 3) : (0, _login.loginBrowser)(params));
+
+    if (userJwt) {
+      const personalAccessToken = await (0, _data.createPersonalAccessToken)(params, userJwt);
+      await (0, _config.writeHomeConfig)(personalAccessToken);
+    }
+  } catch (e) {
+    (0, _log.default)(e);
+  }
+};
+
+var _default = login;
+exports.default = _default;

package/dist/commands/logout.d.ts

@@ -0,0 +1,4 @@
+import { Handler } from '../types';
+declare const logout: Handler;
+export default logout;
+//# sourceMappingURL=logout.d.ts.map

package/dist/commands/logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../../src/commands/logout.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,OAAO,EAAsB,MAAM,UAAU,CAAC;AAItD,QAAA,MAAM,MAAM,EAAE,OASb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/commands/logout.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _log = _interopRequireDefault(require("../log"));
+
+var _types = require("../types");
+
+var _config = require("../config");
+
+var _data = require("../util/data");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const logout = async (_, params) => {
+  try {
+    if ((0, _types.isLoggedInCliConfig)(params)) {
+      await (0, _data.deletePersonalAccessToken)(params);
+      (0, _config.deleteHomeConfig)();
+    }
+  } catch (e) {
+    (0, _log.default)(e);
+  }
+};
+
+var _default = logout;
+exports.default = _default;

package/dist/commands/schema.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../types").Handler;
+export default _default;
+//# sourceMappingURL=schema.d.ts.map

package/dist/commands/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/commands/schema.ts"],"names":[],"mappings":";AAKA,wBAGG"}

package/dist/commands/schema.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _linkedCommand = require("../util/linked-command");
+
+var _connector = require("../util/connector");
+
+var _getClientSchema = _interopRequireDefault(require("../util/get-client-schema"));
+
+var _branches = require("../util/branches");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _linkedCommand.linkedCommand)(async (cli, params) => {
+  const connector = (0, _connector.createConnector)(params, (0, _branches.getBranchParams)(cli), {
+    cache: false
+  });
+  await (0, _getClientSchema.default)(connector);
+});
+
+exports.default = _default;

package/dist/commands/status.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../types").Handler;
+export default _default;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/commands/status.ts"],"names":[],"mappings":";AAGA,wBAEG"}

package/dist/commands/status.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _linkedCommand = require("../util/linked-command");
+
+var _log = _interopRequireDefault(require("../log"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _linkedCommand.linkedCommand)(async (cli, params) => {
+  (0, _log.default)(`Project: ${params.projectName} \nStatic Site: ${params.siteName ?? 'not configured'}`);
+});
+
+exports.default = _default;

package/dist/commands/types.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../types").Handler;
+export default _default;
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/commands/types.ts"],"names":[],"mappings":";AAeA,wBAGG"}

package/dist/commands/types.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _linkedCommand = require("../util/linked-command");
+
+var _generateTypes = require("../util/generate-types");
+
+var _getClientSchema = require("../util/get-client-schema");
+
+const DEFAULT_GENERATED_FILE = './takeshape.d.ts';
+/*
+takeshape types --to ./takeshape.d.ts
+
+Generate TypeScript types from your TakeShape schema.
+
+Options:
+  --in: if provided, will generate types used
+  --to: the path to save the download or the full file path, defaults to current directory
+*/
+
+var _default = (0, _linkedCommand.linkedCommand)(async cli => {
+  const output = cli.flags.to ?? DEFAULT_GENERATED_FILE;
+  await (0, _generateTypes.generateTypes)(_getClientSchema.SCHEMA_FILE_NAME, output);
+});
+
+exports.default = _default;

package/dist/commands/unlink.d.ts

@@ -0,0 +1,4 @@
+import { Handler } from '../types';
+declare const unlink: Handler;
+export default unlink;
+//# sourceMappingURL=unlink.d.ts.map