@prismatic-io/prism 3.2.2 → 4.1.0

package/lib/utils/component/publish.js

@@ -0,0 +1,219 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadConnectionIcons = exports.uploadFile = exports.publishDefinition = exports.confirmPublish = exports.checkSignature = exports.createComponentPackage = exports.validateDefinition = exports.loadEntrypoint = exports.seekComponentPackageDistDirectory = void 0;
+const core_1 = require("@oclif/core");
+const fs_1 = require("../../fs");
+const path_1 = require("path");
+const tempy_1 = __importDefault(require("tempy"));
+const crypto_1 = __importDefault(require("crypto"));
+const archiver_1 = __importDefault(require("archiver"));
+const graphql_1 = require("../../graphql");
+const axios_1 = __importDefault(require("axios"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const path_2 = require("path");
+const seekComponentPackageDistDirectory = async () => {
+    while (!(await (0, fs_1.exists)("package.json"))) {
+        const tempDir = process.cwd();
+        process.chdir("../");
+        if (process.cwd() == tempDir) {
+            core_1.CliUx.ux.error("Failed to find 'package.json' file. Is the current path a component?", { exit: 1 });
+        }
+    }
+    if (!(await (0, fs_1.exists)("./dist"))) {
+        core_1.CliUx.ux.error("Failed to find 'dist' folder. Is the current path a component?", {
+            exit: 1,
+        });
+    }
+    process.chdir("./dist");
+};
+exports.seekComponentPackageDistDirectory = seekComponentPackageDistDirectory;
+const loadEntrypoint = async () => {
+    // If we don't have an index.js in cwd seek directories to find package.json of component
+    if (!(await (0, fs_1.exists)("index.js"))) {
+        await (0, exports.seekComponentPackageDistDirectory)();
+    }
+    // If we still didn't find index.js error out
+    if (!(await (0, fs_1.exists)("index.js"))) {
+        core_1.CliUx.ux.error("Failed to find 'index.js' entrypoint file. Is the current path a component?", { exit: 1 });
+    }
+    // Require index.js and access its root-most default export which should be the Component config
+    const cwd = process.cwd();
+    const entrypointPath = (0, path_1.resolve)(cwd, "./index.js");
+    const { default: definition } = require(entrypointPath); // eslint-disable-line @typescript-eslint/no-var-requires
+    return definition;
+};
+exports.loadEntrypoint = loadEntrypoint;
+const validateDefinition = async (definition) => {
+    // Output basic information to the user to confirm that this component is what they want to publish
+    const { display: { label, description, iconPath },
+    // connections,
+     } = definition;
+    if (!label || !description) {
+        core_1.CliUx.ux.error("Missing required values `label` or `description`. Exiting.", { exit: 1 });
+    }
+    if (iconPath && !(await (0, fs_1.exists)(iconPath))) {
+        core_1.CliUx.ux.error("Icon was specified (iconPath) but a file was not found at specified path. Exiting.", { exit: 1 });
+    }
+    // TODO: Check if all Connection icons exist.
+};
+exports.validateDefinition = validateDefinition;
+const createComponentPackage = async () => {
+    const zip = (0, archiver_1.default)("zip", { zlib: { level: 9 } });
+    const pathPromise = tempy_1.default.write(zip, { extension: "zip" });
+    // Zip all files in the current directory (since we found the index.js entrypoint)
+    zip.directory(process.cwd(), false);
+    await zip.finalize();
+    return pathPromise;
+};
+exports.createComponentPackage = createComponentPackage;
+const checkSignature = async ({ key }, packagePath) => {
+    // Retrieve the existing signature of the component if it exists.
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query component($key: String!) {
+        components(key: $key) {
+          nodes {
+            signature
+          }
+        }
+      }
+    `,
+        variables: {
+            key,
+        },
+    });
+    const { components: { nodes: [{ signature: existingSignature } = { signature: null }], }, } = result;
+    // Generate the signature of the package so we may compare it against the existing one.
+    const packageSignature = crypto_1.default
+        .createHash("sha1")
+        .update(await fs_1.fs.readFile(packagePath))
+        .digest("hex");
+    return existingSignature === packageSignature;
+};
+exports.checkSignature = checkSignature;
+const confirmPublish = async ({ display: { label, description } }, confirm = true) => {
+    if (!confirm)
+        return;
+    core_1.CliUx.ux.log(label, "-", description);
+    const continuePublish = await core_1.CliUx.ux.confirm(`Would you like to publish ${label}? (y/N)`);
+    if (!continuePublish)
+        core_1.CliUx.ux.exit(0);
+};
+exports.confirmPublish = confirmPublish;
+const publishDefinition = async ({ actions, triggers, connections, ...rest }, comment) => {
+    // FIXME: Ideally we should just pass the entire configuration blob but Graphene can't represent
+    // a dictionary having arbitrary keys. For now, split actions and triggers out.
+    const actionDefinitions = Object.values(actions || {}).map((action) => {
+        return {
+            ...action,
+            examplePayload: (action === null || action === void 0 ? void 0 : action.examplePayload)
+                ? JSON.stringify(action === null || action === void 0 ? void 0 : action.examplePayload)
+                : JSON.stringify({}),
+        };
+    });
+    const triggerDefinitions = Object.values(triggers || {}).map((trigger) => {
+        return {
+            ...trigger,
+            examplePayload: (trigger === null || trigger === void 0 ? void 0 : trigger.examplePayload)
+                ? JSON.stringify(trigger === null || trigger === void 0 ? void 0 : trigger.examplePayload)
+                : JSON.stringify({}),
+        };
+    });
+    const connectionDefinitions = connections || [];
+    // Initiate start of the publish procedure by sending config data and receive back presigned s3 URL
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      mutation publishComponent(
+        $definition: ComponentDefinitionInput!
+        $actions: [ActionDefinitionInput]!
+        $triggers: [TriggerDefinitionInput]
+        $connections: [ConnectionDefinitionInput]
+        $comment: String
+      ) {
+        publishComponent(
+          input: {
+            definition: $definition
+            actions: $actions
+            triggers: $triggers
+            connections: $connections
+            comment: $comment
+          }
+        ) {
+          publishResult {
+            component {
+              id
+              versionNumber
+            }
+            iconUploadUrl
+            packageUploadUrl
+            connectionIconUploadUrls {
+              connectionKey
+              iconUploadUrl
+            }
+          }
+          errors {
+            field
+            messages
+          }
+        }
+      }
+    `,
+        variables: {
+            definition: rest,
+            actions: actionDefinitions,
+            triggers: triggerDefinitions,
+            connections: connectionDefinitions,
+            comment,
+        },
+    });
+    const { iconUploadUrl, packageUploadUrl, connectionIconUploadUrls, component: { versionNumber }, } = result.publishComponent.publishResult;
+    const uploadUrls = connectionIconUploadUrls.reduce((result, { connectionKey, iconUploadUrl }) => ({
+        ...result,
+        [connectionKey]: iconUploadUrl,
+    }), {});
+    return {
+        iconUploadUrl,
+        packageUploadUrl,
+        connectionIconUploadUrls: uploadUrls,
+        versionNumber,
+    };
+};
+exports.publishDefinition = publishDefinition;
+const uploadFile = async (filePath, destinationUrl) => {
+    try {
+        // TODO: Stream instead of Buffer.
+        const response = await axios_1.default.put(destinationUrl, await fs_1.fs.readFile(filePath), { headers: { "Content-Type": mime_types_1.default.contentType((0, path_2.extname)(filePath)) } });
+        return response;
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error)) {
+            const { message } = error;
+            throw new Error(message);
+        }
+        throw error;
+    }
+};
+exports.uploadFile = uploadFile;
+const uploadConnectionIcons = async ({ connections }, connectionIconUploadUrls) => {
+    if (!connections ||
+        !connections.length ||
+        !connectionIconUploadUrls ||
+        !Object.keys(connectionIconUploadUrls).length) {
+        return;
+    }
+    const iconPaths = connections.reduce((result, { key, iconPath }) => {
+        if (!iconPath) {
+            return result;
+        }
+        return {
+            ...result,
+            [key]: iconPath,
+        };
+    }, {});
+    const promises = Object.entries(connectionIconUploadUrls).map(async ([connectionKey, uploadUrl]) => (0, exports.uploadFile)(iconPaths[connectionKey], uploadUrl));
+    await Promise.all(promises);
+};
+exports.uploadConnectionIcons = uploadConnectionIcons;

package/lib/utils/component/query.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryComponentKeys = void 0;
+const graphql_1 = require("../../graphql");
+const queryComponentKeys = async (keys) => {
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query components($keys: [String]!) {
+        components(key_In: $keys) {
+          nodes {
+            id
+            key
+            versionNumber
+            public
+          }
+        }
+      }
+    `,
+        variables: { keys },
+    });
+    return result.components.nodes;
+};
+exports.queryComponentKeys = queryComponentKeys;

package/lib/utils/date.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTimestamp = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const timezone_1 = __importDefault(require("dayjs/plugin/timezone"));
+dayjs_1.default.extend(utc_1.default);
+dayjs_1.default.extend(timezone_1.default);
+const formatTimestamp = (timestamp) => (0, dayjs_1.default)(timestamp, "YYYY-MM-DDTHH:mm:ss.SSS000+Z", true).format("HH:mm:ss.SSS");
+exports.formatTimestamp = formatTimestamp;
+exports.default = dayjs_1.default;

package/lib/utils/execution/logs.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayLogs = exports.waitForExecutionCompletion = void 0;
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const date_1 = require("../date");
+const graphql_1 = require("../../graphql");
+const util_1 = require("util");
+const setTimeoutPromise = (0, util_1.promisify)(setTimeout);
+const waitForExecutionCompletion = (executionId) => {
+    return new Promise((resolve, reject) => {
+        const interval = setInterval(async () => {
+            try {
+                const result = await (0, graphql_1.gqlRequest)({
+                    document: (0, graphql_1.gql) `
+            query pollExecution($executionId: ID!) {
+              executionResult(id: $executionId) {
+                endedAt
+              }
+            }
+          `,
+                    variables: { executionId },
+                });
+                const { endedAt } = result.executionResult;
+                if (endedAt) {
+                    clearInterval(interval);
+                    // Grace period to let logs finish flowing; logs are fully async and are
+                    // not guaranteed to be added in chronological order.
+                    await setTimeoutPromise(1000);
+                    resolve();
+                }
+            }
+            catch (error) {
+                clearInterval(interval);
+                reject(error);
+            }
+        }, 1000);
+    });
+};
+exports.waitForExecutionCompletion = waitForExecutionCompletion;
+const displayLogs = async (executionId) => {
+    await (0, exports.waitForExecutionCompletion)(executionId);
+    // TODO: Add paging
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query logs($executionId: ID!) {
+        executionResult(id: $executionId) {
+          logs(orderBy: { field: TIMESTAMP, direction: ASC }) {
+            nodes {
+              timestamp
+              severity
+              message
+            }
+          }
+        }
+      }
+    `,
+        variables: { executionId },
+    });
+    const logs = result.executionResult.logs.nodes;
+    core_1.CliUx.ux.table(logs, {
+        timestamp: {
+            get: ({ timestamp }) => (0, date_1.formatTimestamp)(timestamp),
+        },
+        severity: {
+            minWidth: 12,
+            get: ({ severity }) => {
+                if (severity == "INFO") {
+                    return chalk_1.default.blue("info");
+                }
+                if (severity == "WARN") {
+                    return chalk_1.default.yellow("warn");
+                }
+                if (severity == "ERROR") {
+                    return chalk_1.default.red("error");
+                }
+                return severity.toLowerCase();
+            },
+        },
+        message: {},
+    }, { "no-header": true });
+};
+exports.displayLogs = displayLogs;

package/lib/utils/integration/definition.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComponentTestHarnessIntegration = exports.defaultDefinition = exports.buildStep = exports.buildConnectionConfigVar = exports.componentTestIntegrationName = void 0;
+const serialize_1 = require("../serialize");
+const lodash_1 = require("lodash");
+const export_1 = require("./export");
+const componentTestIntegrationName = (componentKey, name) => `Component Test Harness - ${componentKey} - ${name}`;
+exports.componentTestIntegrationName = componentTestIntegrationName;
+const buildConnectionConfigVar = ({ key: componentKey, isPublic }, { key, values }) => {
+    return {
+        key: "testConnection",
+        description: "Test Connection",
+        dataType: "connection",
+        connection: {
+            component: {
+                key: componentKey,
+                isPublic,
+                version: "LATEST",
+            },
+            key,
+        },
+        inputs: values,
+    };
+};
+exports.buildConnectionConfigVar = buildConnectionConfigVar;
+const buildStep = ({ key: componentKey, isPublic }, { key, values }) => {
+    return {
+        name: "Test Step",
+        action: {
+            component: {
+                key: componentKey,
+                isPublic,
+                version: "LATEST",
+            },
+            key,
+        },
+        inputs: values,
+    };
+};
+exports.buildStep = buildStep;
+const defaultDefinition = ({ integrationInfo: { name: integrationName }, componentInfo, actionInfo, connectionInfo, }) => {
+    const requiredConfigVars = connectionInfo
+        ? [(0, exports.buildConnectionConfigVar)(componentInfo, connectionInfo)]
+        : [];
+    const { key: componentKey } = componentInfo;
+    const definition = {
+        definitionVersion: 6,
+        name: integrationName,
+        description: `Test Harness for the ${componentKey} Component`,
+        category: "Component Development",
+        requiredConfigVars,
+        flows: [
+            {
+                name: "Flow 1",
+                steps: [
+                    {
+                        name: "Trigger",
+                        isTrigger: true,
+                        action: {
+                            component: {
+                                key: "webhook-triggers",
+                                isPublic: true,
+                                version: "LATEST",
+                            },
+                            key: "webhook",
+                        },
+                    },
+                    (0, exports.buildStep)(componentInfo, actionInfo),
+                ],
+            },
+        ],
+    };
+    return definition;
+};
+exports.defaultDefinition = defaultDefinition;
+const buildComponentTestHarnessIntegration = async (info) => {
+    var _a, _b;
+    const { integrationInfo: { id: integrationId }, componentInfo, actionInfo, connectionInfo, } = info;
+    const definition = integrationId
+        ? await (0, export_1.exportDefinition)({ integrationId })
+        : (0, exports.defaultDefinition)(info);
+    // Update "current definition" accordingly.
+    if (connectionInfo) {
+        const connection = (0, exports.buildConnectionConfigVar)(componentInfo, connectionInfo);
+        const existingConnection = (_b = (_a = definition.requiredConfigVars) === null || _a === void 0 ? void 0 : _a.filter(({ key }) => key === "testConnection")) === null || _b === void 0 ? void 0 : _b[0];
+        if (existingConnection) {
+            (0, lodash_1.merge)(existingConnection, connection);
+        }
+        else if (definition.requiredConfigVars) {
+            definition.requiredConfigVars.push(connection);
+        }
+        else {
+            definition.requiredConfigVars = [connection];
+        }
+    }
+    const step = (0, exports.buildStep)(componentInfo, actionInfo);
+    const existingStep = definition.flows[0].steps.filter(({ name }) => name === "Test Step")[0];
+    (0, lodash_1.merge)(existingStep, step);
+    return (0, serialize_1.dumpYaml)(definition);
+};
+exports.buildComponentTestHarnessIntegration = buildComponentTestHarnessIntegration;

package/lib/utils/integration/export.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportDefinition = exports.INTEGRATION_DEFINITION_VERSION = void 0;
+const graphql_1 = require("../../graphql");
+const serialize_1 = require("../serialize");
+/** The version of the Integration definition to request.
+ *  It's important to request a version that corresponds with the
+ *  feature set in this version.
+ */
+exports.INTEGRATION_DEFINITION_VERSION = 6;
+const exportDefinition = async ({ integrationId, latestComponents = false, definitionVersion = exports.INTEGRATION_DEFINITION_VERSION, }) => {
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query export(
+        $id: ID!
+        $version: Int!
+        $useLatestComponentVersions: Boolean!
+      ) {
+        integration(id: $id) {
+          definition(
+            version: $version
+            useLatestComponentVersions: $useLatestComponentVersions
+          )
+        }
+      }
+    `,
+        variables: {
+            id: integrationId,
+            version: definitionVersion,
+            useLatestComponentVersions: latestComponents,
+        },
+    });
+    const definition = result.integration.definition;
+    return (0, serialize_1.loadYaml)(definition);
+};
+exports.exportDefinition = exportDefinition;

package/lib/utils/integration/import.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importDefinition = void 0;
+const graphql_1 = require("../../graphql");
+const importDefinition = async (definition, integrationId) => {
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      mutation importIntegration($definition: String!, $integrationId: ID) {
+        importIntegration(
+          input: { definition: $definition, integrationId: $integrationId }
+        ) {
+          integration {
+            id
+            flows {
+              nodes {
+                id
+                name
+              }
+            }
+            testConfigVariables(status: "pending") {
+              nodes {
+                id
+                authorizeUrl
+              }
+            }
+          }
+          errors {
+            field
+            messages
+          }
+        }
+      }
+    `,
+        variables: {
+            definition,
+            integrationId,
+        },
+    });
+    const integration = result.importIntegration.integration;
+    return {
+        integrationId: integration.id,
+        flows: integration.flows.nodes,
+        pendingAuthorizations: integration.testConfigVariables.nodes.map(({ id, authorizeUrl: url }) => ({ id, url })),
+    };
+};
+exports.importDefinition = importDefinition;

package/lib/utils/integration/invoke.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runIntegrationFlow = exports.getIntegrationFlow = void 0;
+const graphql_1 = require("../../graphql");
+/** Return Flow ID of given flow name on specified Integration. */
+const getIntegrationFlow = async (integrationId, flowName) => {
+    // TODO: Make flows searchable by name.
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query flowId($integrationID: ID!) {
+        integration(id: $id) {
+          flows {
+            nodes {
+              id
+              name
+            }
+          }
+        }
+      }
+    `,
+        variables: { integrationID: integrationId },
+    });
+    const integration = result.integration;
+    const flows = integration.flows.nodes
+        .map(({ id, name }) => ({
+        id,
+        name: name.toLowerCase().trim(),
+    }))
+        .filter(({ name }) => name === flowName);
+    if (flows.length > 1) {
+        throw new Error(`Found more than one result for Flow name: ${flowName}`);
+    }
+    if (flows.length === 0) {
+        throw new Error(`Failed to find a Flow with the given name: ${flowName}`);
+    }
+    return flows[0].id;
+};
+exports.getIntegrationFlow = getIntegrationFlow;
+const runIntegrationFlow = async ({ integrationId, flowId, flowName, }) => {
+    const integrationFlowId = flowName
+        ? await (0, exports.getIntegrationFlow)(integrationId, flowName)
+        : flowId;
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      mutation testIntegrationFlow($id: ID!) {
+        testIntegrationFlow(input: { id: $id }) {
+          testIntegrationFlowResult {
+            execution {
+              id
+            }
+          }
+          errors {
+            field
+            messages
+          }
+        }
+      }
+    `,
+        variables: { id: integrationFlowId },
+    });
+    const executionId = result.testIntegrationFlow.testIntegrationFlowResult.execution.id;
+    return { executionId };
+};
+exports.runIntegrationFlow = runIntegrationFlow;

package/lib/utils/integration/query.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollForActiveConfigVarState = exports.integrationByName = void 0;
+const graphql_1 = require("../../graphql");
+const integrationByName = async (name) => {
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query integration($name: String!) {
+        integrations(name: $name) {
+          nodes {
+            id
+          }
+        }
+      }
+    `,
+        variables: { name },
+    });
+    const [integration, ...rest] = result.integrations.nodes;
+    if (rest.length !== 0) {
+        throw new Error(`Found more than one Integration with name: ${name}`);
+    }
+    return integration;
+};
+exports.integrationByName = integrationByName;
+const pollForActiveConfigVarState = async (integrationId, configVarId) => {
+    return new Promise((resolve, reject) => {
+        const interval = setInterval(async () => {
+            try {
+                const result = await (0, graphql_1.gqlRequest)({
+                    document: (0, graphql_1.gql) `
+            query state($integrationId: ID!) {
+              integration(id: $integrationId) {
+                testConfigVariables(status_In: ["pending", "active", "error"]) {
+                  nodes {
+                    id
+                    status
+                  }
+                }
+              }
+            }
+          `,
+                    variables: { integrationId },
+                });
+                const testConfigVariables = result.integration.testConfigVariables.nodes;
+                const [{ status: serverStatus }] = testConfigVariables.filter(({ id }) => id === configVarId);
+                const status = serverStatus.toLowerCase();
+                if (status !== "pending") {
+                    clearInterval(interval);
+                    resolve(status === "active");
+                }
+            }
+            catch (error) {
+                clearInterval(interval);
+                reject(error);
+            }
+        }, 5000);
+    });
+};
+exports.pollForActiveConfigVarState = pollForActiveConfigVarState;

package/lib/utils/serialize.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadYaml = exports.dumpYaml = void 0;
+const js_yaml_1 = require("js-yaml");
+const dumpYaml = (value, extraOptions) => (0, js_yaml_1.dump)(value, { ...extraOptions, noRefs: true });
+exports.dumpYaml = dumpYaml;
+const loadYaml = (value, extraOptions) => (0, js_yaml_1.load)(value, { ...extraOptions });
+exports.loadYaml = loadYaml;

package/lib/utils/user/query.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whoAmI = void 0;
+const graphql_1 = require("../../graphql");
+const whoAmI = async () => {
+    const { authenticatedUser } = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query whoami {
+        authenticatedUser {
+          name
+          email
+          org {
+            name
+          }
+          customer {
+            name
+          }
+        }
+      }
+    `,
+    });
+    return authenticatedUser;
+};
+exports.whoAmI = whoAmI;