eas-cli 20.3.0 → 20.4.0

package/build/observe/formatEvents.d.ts

@@ -16,6 +16,7 @@ export interface ObserveEventJson {
     customParams: {
         [key: string]: any;
     } | null;
+    routeName: string | null;
 }
 export interface BuildEventsTableOptions {
     metricName: string;

package/build/observe/formatEvents.js

@@ -65,6 +65,7 @@ function buildObserveEventsJson(events, pageInfo) {
             easClientId: event.easClientId,
             timestamp: event.timestamp,
             customParams: resolveCustomParams(event),
+            routeName: event.routeName ?? null,
         })),
         pageInfo: {
             hasNextPage: pageInfo.hasNextPage,

package/build/observe/formatSessions.d.ts

@@ -0,0 +1,15 @@
+import { SessionEventEntry, SessionMetadata } from './fetchSessions';
+export interface BuildSessionEventsOptions {
+    metadata?: SessionMetadata | null;
+    hasMoreMetricEvents?: boolean;
+    hasMoreLogEvents?: boolean;
+}
+export declare function buildObserveSessionEventsTable(entries: SessionEventEntry[], options?: BuildSessionEventsOptions): string;
+export interface ObserveSessionEventsJson {
+    sessionId: string;
+    metadata: SessionMetadata | null;
+    entries: SessionEventEntry[];
+    hasMoreMetricEvents: boolean;
+    hasMoreLogEvents: boolean;
+}
+export declare function buildObserveSessionEventsJson(entries: SessionEventEntry[], sessionId: string, metadata: SessionMetadata | null, hasMoreMetricEvents: boolean, hasMoreLogEvents: boolean): ObserveSessionEventsJson;

package/build/observe/formatSessions.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildObserveSessionEventsTable = buildObserveSessionEventsTable;
+exports.buildObserveSessionEventsJson = buildObserveSessionEventsJson;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const formatUtils_1 = require("./formatUtils");
+const metricNames_1 = require("./metricNames");
+const renderTextTable_1 = tslib_1.__importDefault(require("../utils/renderTextTable"));
+function formatEntryName(entry) {
+    if (entry.source === 'metric' && entry.metricName) {
+        const name = (0, metricNames_1.getMetricDisplayName)(entry.metricName);
+        return entry.routeName ? `${name} · ${entry.routeName}` : name;
+    }
+    return entry.eventName ?? '-';
+}
+function formatMetricEntryValue(entry) {
+    if (typeof entry.metricValue === 'number') {
+        return `${entry.metricValue.toFixed(2)}s`;
+    }
+    return '-';
+}
+function formatEntrySeverity(entry) {
+    if (entry.source !== 'log') {
+        return '-';
+    }
+    if (entry.severityText) {
+        return entry.severityText;
+    }
+    if (entry.severityNumber != null) {
+        return String(entry.severityNumber);
+    }
+    return '-';
+}
+function primitivePropertyLines(entry) {
+    if (entry.source !== 'log' || !entry.properties) {
+        return [];
+    }
+    return entry.properties
+        .filter(p => p.type === 'STRING' || p.type === 'NUMBER' || p.type === 'BOOLEAN')
+        .map(p => `${p.key}=${p.value}`);
+}
+function formatOffsetSeconds(startIso, currentIso) {
+    const offsetMs = new Date(currentIso).getTime() - new Date(startIso).getTime();
+    return `${(offsetMs / 1000).toFixed(2)}s`;
+}
+function buildObserveSessionEventsTable(entries, options) {
+    const lines = [];
+    if (options?.metadata) {
+        const { metadata } = options;
+        lines.push(`App version: ${metadata.appVersion} (${metadata.appBuildNumber})`, `Device:      ${metadata.deviceModel} · ${metadata.deviceOs} ${metadata.deviceOsVersion}`, `First seen:  ${(0, formatUtils_1.formatLogTimestamp)(metadata.firstSeenAt)}`, `Last seen:   ${(0, formatUtils_1.formatLogTimestamp)(metadata.lastSeenAt)}`, '');
+    }
+    if (entries.length === 0) {
+        lines.push(chalk_1.default.yellow('No events found for this session.'));
+        return lines.join('\n');
+    }
+    const startIso = entries[0].timestamp;
+    const headers = ['Offset', 'Type', 'Name', 'Value', 'Properties', 'Severity'];
+    const rows = [];
+    for (const entry of entries) {
+        const offset = formatOffsetSeconds(startIso, entry.timestamp);
+        const type = entry.source === 'metric' ? 'metric' : 'log';
+        const name = formatEntryName(entry);
+        const severity = formatEntrySeverity(entry);
+        if (entry.source === 'metric') {
+            rows.push([offset, type, name, formatMetricEntryValue(entry), '-', severity]);
+            continue;
+        }
+        const propLines = primitivePropertyLines(entry);
+        if (propLines.length === 0) {
+            rows.push([offset, type, name, '-', '-', severity]);
+            continue;
+        }
+        rows.push([offset, type, name, '-', propLines[0], severity]);
+        for (let i = 1; i < propLines.length; i++) {
+            rows.push(['', '', '', '', propLines[i], '']);
+        }
+    }
+    lines.push((0, renderTextTable_1.default)(headers, rows));
+    if (options?.hasMoreMetricEvents || options?.hasMoreLogEvents) {
+        const sources = [];
+        if (options.hasMoreMetricEvents) {
+            sources.push('metric events');
+        }
+        if (options.hasMoreLogEvents) {
+            sources.push('log events');
+        }
+        lines.push('', chalk_1.default.yellow(`More ${sources.join(' and ')} are available for this session; only the first 100 of each are shown.`));
+    }
+    return lines.join('\n');
+}
+function buildObserveSessionEventsJson(entries, sessionId, metadata, hasMoreMetricEvents, hasMoreLogEvents) {
+    return {
+        sessionId,
+        metadata,
+        entries,
+        hasMoreMetricEvents,
+        hasMoreLogEvents,
+    };
+}

package/build/update/getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync.js

@@ -6,40 +6,37 @@ const errors_1 = require("../channel/errors");
 const queries_2 = require("../channel/queries");
 const ChannelQuery_1 = require("../graphql/queries/ChannelQuery");
 async function getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync(graphqlClient, projectId, channelName) {
-    let branchInfo;
+    let channel;
     try {
-        const channel = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+        channel = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
             appId: projectId,
             channelName,
         });
-        if (channel.updateBranches.length === 1) {
-            const branch = channel.updateBranches[0];
-            branchInfo = { branchId: branch.id, branchName: branch.name };
-        }
-        else if (channel.updateBranches.length === 0) {
-            throw new Error("Channel has no branches associated with it. Run 'eas channel:edit' to map a branch");
-        }
-        else {
-            throw new Error(`Channel has multiple branches associated with it. Instead, use '--branch' instead of '--channel'`);
-        }
     }
     catch (error) {
         if (!(error instanceof errors_1.ChannelNotFoundError)) {
             throw error;
         }
-        const { branch } = await (0, queries_1.ensureBranchExistsAsync)(graphqlClient, {
-            appId: projectId,
-            branchName: channelName,
-        });
-        const { updateChannel: { createUpdateChannelForApp: newChannel }, } = await (0, queries_2.createChannelOnAppAsync)(graphqlClient, {
-            appId: projectId,
-            channelName,
-            branchId: branch.id,
-        });
-        if (!newChannel) {
-            throw new Error(`Could not create channel with name ${channelName} on project with id ${projectId}`);
-        }
-        branchInfo = { branchId: branch.id, branchName: channelName };
+        return await createAndLinkBranchToChannelAsync(graphqlClient, projectId, channelName);
     }
-    return branchInfo;
+    if (channel.updateBranches.length === 1) {
+        const branch = channel.updateBranches[0];
+        return { branchId: branch.id, branchName: branch.name };
+    }
+    if (channel.updateBranches.length === 0) {
+        return await createAndLinkBranchToChannelAsync(graphqlClient, projectId, channelName);
+    }
+    throw new Error(`Channel has multiple branches associated with it. Instead, use '--branch' instead of '--channel'`);
+}
+async function createAndLinkBranchToChannelAsync(graphqlClient, projectId, channelName) {
+    const { branch } = await (0, queries_1.ensureBranchExistsAsync)(graphqlClient, {
+        appId: projectId,
+        branchName: channelName,
+    });
+    await (0, queries_2.createChannelOnAppAsync)(graphqlClient, {
+        appId: projectId,
+        channelName,
+        branchId: branch.id,
+    });
+    return { branchId: branch.id, branchName: channelName };
 }