@sentry/wizard 4.0.0 → 4.0.1

package/src/utils/ast-utils.ts

@@ -1,270 +0,0 @@
-import * as fs from 'fs';
-
-import * as recast from 'recast';
-import x = recast.types;
-import t = x.namedTypes;
-
-const b = recast.types.builders;
-
-/**
- * Checks if a file where we don't know its concrete file type yet exists
- * and returns the full path to the file with the correct file type.
- */
-export function findFile(
-  filePath: string,
-  fileTypes: string[] = ['.js', '.ts', '.mjs', '.cjs'],
-): string | undefined {
-  return fileTypes
-    .map((type) => `${filePath}${type}`)
-    .find((file) => fs.existsSync(file));
-}
-
-/**
- * checks for require('@sentry/*') syntax
- */
-export function hasSentryContent(program: t.Program): boolean {
-  let foundSentry: boolean | undefined = false;
-  recast.visit(program, {
-    visitStringLiteral(path) {
-      foundSentry = foundSentry || path.node.value.startsWith('@sentry/');
-      this.traverse(path);
-    },
-    visitLiteral(path) {
-      foundSentry =
-        foundSentry || path.node.value?.toString().startsWith('@sentry/');
-      this.traverse(path);
-    },
-  });
-
-  return !!foundSentry;
-}
-
-/**
- * Searches for a property of an ObjectExpression by name
- *
- * @param object the ObjectExpression to search in
- * @param name the name of the property to search for
- *
- * @returns the property if it exists
- */
-export function getObjectProperty(
-  object: t.ObjectExpression,
-  name: string,
-): t.Property | undefined {
-  return object.properties.find((p): p is t.Property => {
-    const isObjectProp = p.type === 'Property' || p.type === 'ObjectProperty';
-
-    if (!isObjectProp) {
-      return false;
-    }
-
-    const hasMatchingLiteralKey =
-      isObjectProp &&
-      (p.key.type === 'Literal' || p.key.type === 'StringLiteral') &&
-      p.key.value === name;
-
-    if (hasMatchingLiteralKey) {
-      return true;
-    }
-
-    // has matching identifier key
-    return isObjectProp && p.key.type === 'Identifier' && p.key.name === name;
-  });
-}
-
-/**
- * Attempts to find a property of an ObjectExpression by name. If it doesn't exist,
- * the property will be added to the ObjectExpression with the provided default value.
- *
- * @param object the parent object expression to search in
- * @param name the name of the property to search for
- * @param defaultValue the default value to set if the property doesn't exist
- *
- * @returns the
- */
-export function getOrSetObjectProperty(
-  object: t.ObjectExpression,
-  name: string,
-  defaultValue:
-    | t.Literal
-    | t.BooleanLiteral
-    | t.StringLiteral
-    | t.ObjectExpression,
-): t.Property {
-  const existingProperty = getObjectProperty(object, name);
-
-  if (existingProperty) {
-    return existingProperty;
-  }
-
-  const newProperty = b.property.from({
-    kind: 'init',
-    key: b.stringLiteral(name),
-    value: defaultValue,
-  });
-
-  object.properties.push(newProperty);
-
-  return newProperty;
-}
-
-/**
- * Sets a property of an ObjectExpression if it exists, otherwise adds it
- * to the ObjectExpression. Optionally, a comment can be added to the
- * property.
- *
- * @param object the ObjectExpression to set the property on
- * @param name the name of the property to set
- * @param value  the value of the property to set
- * @param comment (optional) a comment to add to the property
- */
-export function setOrUpdateObjectProperty(
-  object: t.ObjectExpression,
-  name: string,
-  value: t.Literal | t.BooleanLiteral | t.StringLiteral | t.ObjectExpression,
-  comment?: string,
-) {
-  const newComments =
-    comment &&
-    comment.split('\n').map((c) => b.commentLine(` ${c}`, true, false));
-
-  const existingProperty = getObjectProperty(object, name);
-
-  if (existingProperty) {
-    existingProperty.value = value;
-    if (newComments) {
-      existingProperty.comments = [
-        ...(existingProperty?.comments || []),
-        ...newComments,
-      ];
-    }
-  } else {
-    object.properties.push(
-      b.objectProperty.from({
-        key: b.stringLiteral(name),
-        value,
-        ...(newComments && {
-          comments: newComments,
-        }),
-      }),
-    );
-  }
-}
-
-type JsonCParseResult =
-  | {
-      jsonObject: t.ObjectExpression;
-      ast: t.Program;
-    }
-  | {
-      jsonObject: undefined;
-      ast: undefined;
-    };
-
-/**
- * Parses a JSON string with (potential) comments (JSON-C) and returns the JS AST
- * that can be walked and modified with recast like a normal JS AST.
- *
- * This is done by wrapping the JSON-C string in parentheses, thereby making it
- * a JS `Program` with an `ExpressionStatement` as its body. The expression is then
- * extracted from the AST and returned alongside the AST.
- *
- * To preserve as much original formatting as possible, the returned `ast`
- * property should be passed to {@link `printJsonC`} to get the JSON-C string back.
- *
- * If the input is not valid JSON-C, the result will be undefined.
- *
- * @see {@link JsonCParseResult}
- *
- * @param jsonString a JSON-C string
- *
- * @returns a {@link JsonCParseResult}, containing either the JSON-C object and the AST or undefined in both cases
- */
-export function parseJsonC(jsonString: string): JsonCParseResult {
-  try {
-    const jsTsConfig = `(${jsonString})`;
-    // no idea why recast returns any here, this is dumb :/
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    const ast = recast.parse(jsTsConfig.toString()).program as t.Program;
-
-    const jsonObject =
-      (ast.body[0].type === 'ExpressionStatement' &&
-        ast.body[0].expression.type === 'ObjectExpression' &&
-        ast.body[0].expression) ||
-      undefined;
-
-    if (jsonObject) {
-      return { jsonObject, ast };
-    }
-  } catch {
-    /* empty */
-  }
-  return { jsonObject: undefined, ast: undefined };
-}
-
-/**
- * Takes the AST of a parsed JSON-C "program" and returns the JSON-C string without
- * any of the temporary JS wrapper code that was previously applied.
- *
- * Only use this in conjunction with {@link `parseJsonC`}
- *
- * @param ast the `ast` returned from {@link `parseJsonC`}
- *
- * @returns the JSON-C string
- */
-export function printJsonC(ast: t.Program): string {
-  const js = recast.print(ast).code;
-  return js.substring(1, js.length - 1);
-}
-
-/**
- * Walks the program body and returns index of the last variable assignment initialized by require statement.
- * Only counts top level require statements.
- *
- * @returns index of the last `const foo = require('bar');` statement or -1 if none was found.
- */
-export function getLastRequireIndex(program: t.Program): number {
-  let lastRequireIdex = -1;
-  program.body.forEach((s, i) => {
-    if (
-      s.type === 'VariableDeclaration' &&
-      s.declarations[0].type === 'VariableDeclarator' &&
-      s.declarations[0].init !== null &&
-      typeof s.declarations[0].init !== 'undefined' &&
-      s.declarations[0].init.type === 'CallExpression' &&
-      s.declarations[0].init.callee.type === 'Identifier' &&
-      s.declarations[0].init.callee.name === 'require'
-    ) {
-      lastRequireIdex = i;
-    }
-  });
-  return lastRequireIdex;
-}
-
-/**
- * Walks the statements and removes require statements which first argument includes the predicate.
- * Only removes top level require statements like `const foo = require('bar');`
- *
- * @returns True if any require statement was removed.
- */
-export function removeRequire(program: t.Program, predicate: string): boolean {
-  let removedAtLeastOne = false;
-  program.body = program.body.filter((s) => {
-    if (
-      s.type === 'VariableDeclaration' &&
-      s.declarations[0].type === 'VariableDeclarator' &&
-      s.declarations[0].init !== null &&
-      typeof s.declarations[0].init !== 'undefined' &&
-      s.declarations[0].init.type === 'CallExpression' &&
-      s.declarations[0].init.callee.type === 'Identifier' &&
-      s.declarations[0].init.callee.name === 'require' &&
-      s.declarations[0].init.arguments[0].type === 'StringLiteral' &&
-      s.declarations[0].init.arguments[0].value.includes(predicate)
-    ) {
-      removedAtLeastOne = true;
-      return false;
-    }
-    return true;
-  });
-  return removedAtLeastOne;
-}

package/src/utils/bash.ts

@@ -1,57 +0,0 @@
-import * as child_process from 'child_process';
-import * as https from 'https';
-import * as fs from 'fs';
-
-export function hasSentryCLI(): boolean {
-  try {
-    child_process.execSync('sentry-cli --version');
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-export async function installSentryCLI(): Promise<void> {
-  const httpAsync = new Promise((resolve, reject) => {
-    const file = fs.createWriteStream('installcli.sh');
-    https.get('https://sentry.io/get-cli/', (response) => {
-      response.pipe(file);
-      file.on('finish', () => {
-        file.close();
-        try {
-          child_process.execSync('bash ./installcli.sh');
-        } catch (e) {
-          reject(e);
-          return;
-        }
-        fs.unlinkSync('installcli.sh');
-        resolve(null);
-      });
-
-      file.on('error', (err) => {
-        fs.unlinkSync('installcli.sh');
-        reject(err);
-      });
-    });
-  });
-
-  await httpAsync;
-}
-
-export function executeSync(command: string): string {
-  const output = child_process.execSync(command);
-  return output.toString();
-}
-
-export function execute(command: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    child_process.exec(command, (error, stdout, _) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-
-      resolve(stdout);
-    });
-  });
-}