@swell/cli 2.6.0 → 2.7.1

package/dist/lib/inspect/notifications.d.ts

@@ -0,0 +1,115 @@
+import { GroupInfo } from './table.js';
+export interface NotificationRecord {
+    api?: string;
+    app_id?: string;
+    enabled?: boolean;
+    id?: string;
+    model?: string;
+    name?: string;
+    v2?: boolean;
+}
+export type ParsedNotificationKey = {
+    id: string;
+    kind: 'hex';
+} | {
+    id: string;
+    kind: 'system_id';
+} | {
+    kind: 'app_full';
+    model: string;
+    name: string;
+    slug: string;
+} | {
+    kind: 'app_short';
+    name: string;
+    slug: string;
+} | {
+    kind: 'bare';
+    name: string;
+} | {
+    input: string;
+    kind: 'invalid';
+};
+/**
+ * Translate a stored model path into its display form.
+ *
+ *   apps/<own-hex>/<x>      → <x>          (own-app prefix is implicit in the slug)
+ *   apps/<other-hex>/<x>    → apps/<other-slug>/<x>
+ *   apps/<unknown-hex>/<x>  → unchanged    (preserve a paste-back form)
+ *   <built-in-model>        → unchanged
+ *
+ * Stripping `apps/<own>/` keeps the common case readable; the rare collision
+ * with a same-named built-in (e.g. an app model literally named
+ * `subscriptions`) is recovered by `expandModelCandidates` at lookup time.
+ */
+export declare function normalizeModelForDisplay(model: string, ownAppId: string | undefined, appSlugById: Record<string, string>): string;
+/**
+ * Produce the column-1 paste-back key for a notification.
+ *
+ *   System (no app_id):   record.id verbatim — already in `com.<model>.<name>` form.
+ *   App with model+name:  `app.<slug>.<model-display>.<name>`
+ *   Anything else:        record.id (degenerate, no meaningful slug)
+ *
+ * Notification identity is `(api, model, name, app_id?)`; collapsing on
+ * `(app_id, name)` alone caused two `notify_me.back-in-stock` rows
+ * (different `model`) to render identically.
+ */
+export declare function formatNotificationKey(record: NotificationRecord, appSlugById: Record<string, string>): string;
+/**
+ * Group a notification record. System rows (no app_id) are not store data —
+ * they belong to the platform and render under a `system` divider at the top.
+ */
+export declare function groupNotificationRecord(record: NotificationRecord, appSlugById: Record<string, string>): GroupInfo;
+/**
+ * Classify a notification identifier. The base `classifyIdentifier` collapses
+ * every dot-segment after `app.<part>.` into `name`, which loses the model.
+ * Notifications need a model-aware split, so they bypass the base classifier.
+ *
+ * Recognised shapes:
+ *   - 24-char hex                    → hex (delegate to base GET-by-id)
+ *   - com.<rest>                     → system_id (canonical platform id)
+ *   - app.<slug>.<model>.<name>      → app_full (triplet lookup)
+ *   - app.<slug>.<name>              → app_short (3-part legacy; ambiguous)
+ *   - bare <name>                    → bare (requires --app= scope; ambiguous)
+ *   - anything else                  → invalid
+ *
+ * Multi-segment names (e.g. `unpaid.v2`) only appear in system notifications,
+ * which arrive via the `com.*` form and never go through `app.*` parsing.
+ */
+export declare function parseNotificationKey(input: string): ParsedNotificationKey;
+/**
+ * Render the disambiguation error body when a `(app_id, name)` query returns
+ * multiple notifications. Caller fetches with `limit = displayLimit + 1` so
+ * we can detect overflow without paging through the whole result set; if
+ * `results.length > displayLimit`, the surplus rows are dropped and a hint
+ * line is appended directing the user to the full key form.
+ */
+export declare function formatDisambiguationError(results: NotificationRecord[], appSlugById: Record<string, string>, identifier: string, displayLimit?: number): string;
+/**
+ * Build the `template` value used on send records at `/notifications` from a
+ * manifest record's fields. Three shapes:
+ *
+ *   System (no app_id):                 <model>.<name>
+ *   App on a standard model:            app_<app_id>.<model>.<name>
+ *   App on a custom (apps/<hex>/x) model: app_<app_id>.apps_<hex>_<x>.<name>
+ *
+ * The custom-model branch transforms slashes to underscores in the model
+ * segment.
+ *
+ * V2 system notifications have `name` literally ending in `.v2` (mirroring the
+ * `id` and the `v2: true` flag), but the send-record `template` strips that
+ * suffix. App notifications carry `v2: true` without the suffix in `name`, so
+ * they pass through unchanged.
+ *
+ * Returns undefined when `model` or `name` is missing.
+ */
+export declare function buildNotificationTemplate(record: NotificationRecord): string | undefined;
+/**
+ * Expand a display-form model into the candidate stored values to try at
+ * lookup time. A bare display token can mean either:
+ *   - the literal built-in model (e.g. `subscriptions`)
+ *   - an own-app model whose `apps/<own>/` prefix was stripped for display
+ * so we try both. `apps/<slug>/x` is resolved to `apps/<hex>/x`; an already-hex
+ * `apps/<hex>/x` passes through unchanged.
+ */
+export declare function expandModelCandidates(modelDisplay: string, appId: string, resolveAppId: (slug: string) => Promise<string>): Promise<string[]>;

package/dist/lib/inspect/notifications.js

@@ -0,0 +1,173 @@
+import { HEX24 } from '../apps/object-id.js';
+const APPS_MODEL = /^apps\/([^/]+)\/(.+)$/;
+/**
+ * Translate a stored model path into its display form.
+ *
+ *   apps/<own-hex>/<x>      → <x>          (own-app prefix is implicit in the slug)
+ *   apps/<other-hex>/<x>    → apps/<other-slug>/<x>
+ *   apps/<unknown-hex>/<x>  → unchanged    (preserve a paste-back form)
+ *   <built-in-model>        → unchanged
+ *
+ * Stripping `apps/<own>/` keeps the common case readable; the rare collision
+ * with a same-named built-in (e.g. an app model literally named
+ * `subscriptions`) is recovered by `expandModelCandidates` at lookup time.
+ */
+export function normalizeModelForDisplay(model, ownAppId, appSlugById) {
+    const match = model.match(APPS_MODEL);
+    if (!match)
+        return model;
+    const [, hex, rest] = match;
+    if (ownAppId && hex === ownAppId)
+        return rest;
+    const slug = appSlugById[hex];
+    return slug ? `apps/${slug}/${rest}` : model;
+}
+/**
+ * Produce the column-1 paste-back key for a notification.
+ *
+ *   System (no app_id):   record.id verbatim — already in `com.<model>.<name>` form.
+ *   App with model+name:  `app.<slug>.<model-display>.<name>`
+ *   Anything else:        record.id (degenerate, no meaningful slug)
+ *
+ * Notification identity is `(api, model, name, app_id?)`; collapsing on
+ * `(app_id, name)` alone caused two `notify_me.back-in-stock` rows
+ * (different `model`) to render identically.
+ */
+export function formatNotificationKey(record, appSlugById) {
+    if (!record.app_id) {
+        return record.id ?? '-';
+    }
+    if (!record.name || !record.model) {
+        return record.id ?? '-';
+    }
+    const slug = appSlugById[record.app_id] ?? record.app_id;
+    const modelDisplay = normalizeModelForDisplay(record.model, record.app_id, appSlugById);
+    return `app.${slug}.${modelDisplay}.${record.name}`;
+}
+/**
+ * Group a notification record. System rows (no app_id) are not store data —
+ * they belong to the platform and render under a `system` divider at the top.
+ */
+export function groupNotificationRecord(record, appSlugById) {
+    if (!record.app_id) {
+        return { slug: '<system>', label: 'system', order: 0 };
+    }
+    const resolved = appSlugById[record.app_id];
+    if (!resolved) {
+        return { slug: '<not resolved>', order: 2 };
+    }
+    return { slug: resolved };
+}
+/**
+ * Classify a notification identifier. The base `classifyIdentifier` collapses
+ * every dot-segment after `app.<part>.` into `name`, which loses the model.
+ * Notifications need a model-aware split, so they bypass the base classifier.
+ *
+ * Recognised shapes:
+ *   - 24-char hex                    → hex (delegate to base GET-by-id)
+ *   - com.<rest>                     → system_id (canonical platform id)
+ *   - app.<slug>.<model>.<name>      → app_full (triplet lookup)
+ *   - app.<slug>.<name>              → app_short (3-part legacy; ambiguous)
+ *   - bare <name>                    → bare (requires --app= scope; ambiguous)
+ *   - anything else                  → invalid
+ *
+ * Multi-segment names (e.g. `unpaid.v2`) only appear in system notifications,
+ * which arrive via the `com.*` form and never go through `app.*` parsing.
+ */
+export function parseNotificationKey(input) {
+    if (HEX24.test(input)) {
+        return { kind: 'hex', id: input };
+    }
+    if (input.startsWith('com.')) {
+        return { kind: 'system_id', id: input };
+    }
+    if (input.startsWith('app.')) {
+        const parts = input.split('.');
+        // Reject any post-prefix empty segment (`app..foo`, `app.foo.`, etc.).
+        // Without this, `app..foo` would classify as `app_short` with an empty
+        // slug and dispatch a useless `/client/apps` lookup.
+        const hasEmptySegment = parts.some((p, i) => i > 0 && p.length === 0);
+        if (hasEmptySegment) {
+            return { kind: 'invalid', input };
+        }
+        if (parts.length === 3) {
+            return { kind: 'app_short', slug: parts[1], name: parts[2] };
+        }
+        if (parts.length >= 4) {
+            const slug = parts[1];
+            const name = parts.at(-1);
+            const model = parts.slice(2, -1).join('.');
+            return { kind: 'app_full', slug, model, name };
+        }
+        return { kind: 'invalid', input };
+    }
+    if (/^[\w-]+$/.test(input)) {
+        return { kind: 'bare', name: input };
+    }
+    return { kind: 'invalid', input };
+}
+/**
+ * Render the disambiguation error body when a `(app_id, name)` query returns
+ * multiple notifications. Caller fetches with `limit = displayLimit + 1` so
+ * we can detect overflow without paging through the whole result set; if
+ * `results.length > displayLimit`, the surplus rows are dropped and a hint
+ * line is appended directing the user to the full key form.
+ */
+export function formatDisambiguationError(results, appSlugById, identifier, displayLimit = 10) {
+    const truncated = results.length > displayLimit;
+    const visible = truncated ? results.slice(0, displayLimit) : results;
+    const lines = visible.map((r) => `  ${formatNotificationKey(r, appSlugById)}`);
+    if (truncated) {
+        lines.push('  … (+more candidates; pass the full key)');
+    }
+    return `Multiple notifications match '${identifier}'. Use the full key:\n${lines.join('\n')}`;
+}
+/**
+ * Build the `template` value used on send records at `/notifications` from a
+ * manifest record's fields. Three shapes:
+ *
+ *   System (no app_id):                 <model>.<name>
+ *   App on a standard model:            app_<app_id>.<model>.<name>
+ *   App on a custom (apps/<hex>/x) model: app_<app_id>.apps_<hex>_<x>.<name>
+ *
+ * The custom-model branch transforms slashes to underscores in the model
+ * segment.
+ *
+ * V2 system notifications have `name` literally ending in `.v2` (mirroring the
+ * `id` and the `v2: true` flag), but the send-record `template` strips that
+ * suffix. App notifications carry `v2: true` without the suffix in `name`, so
+ * they pass through unchanged.
+ *
+ * Returns undefined when `model` or `name` is missing.
+ */
+export function buildNotificationTemplate(record) {
+    if (!record.model || !record.name) {
+        return undefined;
+    }
+    const name = record.v2 === true && record.name.endsWith('.v2')
+        ? record.name.slice(0, -'.v2'.length)
+        : record.name;
+    const match = record.model.match(APPS_MODEL);
+    const modelSegment = match ? `apps_${match[1]}_${match[2]}` : record.model;
+    const prefix = record.app_id ? `app_${record.app_id}.` : '';
+    return `${prefix}${modelSegment}.${name}`;
+}
+/**
+ * Expand a display-form model into the candidate stored values to try at
+ * lookup time. A bare display token can mean either:
+ *   - the literal built-in model (e.g. `subscriptions`)
+ *   - an own-app model whose `apps/<own>/` prefix was stripped for display
+ * so we try both. `apps/<slug>/x` is resolved to `apps/<hex>/x`; an already-hex
+ * `apps/<hex>/x` passes through unchanged.
+ */
+export async function expandModelCandidates(modelDisplay, appId, resolveAppId) {
+    const match = modelDisplay.match(APPS_MODEL);
+    if (match) {
+        const [, sluglike, rest] = match;
+        if (HEX24.test(sluglike))
+            return [modelDisplay];
+        const hex = await resolveAppId(sluglike);
+        return [`apps/${hex}/${rest}`];
+    }
+    return [modelDisplay, `apps/${appId}/${modelDisplay}`];
+}

package/dist/lib/inspect/settings.d.ts

@@ -0,0 +1,61 @@
+import { GroupInfo } from './table.js';
+export interface SettingRecord {
+    api?: string;
+    app_id?: string | null;
+    deprecated?: boolean | null;
+    fields?: Record<string, unknown>;
+    id?: string;
+    label?: string;
+    name?: string;
+}
+/**
+ * Settings identifier grammar (calibrated against `/data/:settings`).
+ *
+ *   `app.<slug-or-hex>` → kind 'app'  — slug must be translated to hex before
+ *                                       a path GET; hex passes through.
+ *   anything else valid → kind 'path' — direct path GET. The endpoint resolves
+ *                                       bare system names (`taxes`), bare app
+ *                                       hexes, and full dotted ids
+ *                                       (`com.taxes`) on the path. No `name`
+ *                                       query needed.
+ *   anything else      → kind 'invalid'
+ *
+ * The 3-segment `app.<slug>.<name>` form is rejected: settings collapse to one
+ * record per app at push time, so there is no sub-section identity the API can
+ * resolve back. Users wanting a single section run `--json | jq`.
+ */
+export type ParsedSettingsKey = {
+    kind: 'app';
+    ref: string;
+} | {
+    kind: 'path';
+    segment: string;
+} | {
+    input: string;
+    kind: 'invalid';
+};
+export declare function parseSettingsKey(input: string): ParsedSettingsKey;
+/**
+ * Produce the column-1 paste-back key for a settings record.
+ *
+ *   System (no app_id):  `record.name` (e.g. `taxes`).
+ *   App with slug:       `app.<slug>`.
+ *   App without slug:    `app.<hex>` (still pasteable — `app.<hex>` resolves).
+ *
+ * App records carry `name === app_id` (the hex), which is meaningless to a
+ * human; we never surface it. Ultimate fallback is `record.id` for degenerate
+ * records that have neither `app_id` nor `name`.
+ */
+export declare function formatSettingsKey(record: SettingRecord, appSlugById: Record<string, string>): string;
+/**
+ * Group a settings record. System rows (`app_id` null/undefined) belong to the
+ * platform and render under a `system` divider at the top, mirroring the
+ * notifications shape.
+ */
+export declare function groupSettingsRecord(record: SettingRecord, appSlugById: Record<string, string>): GroupInfo;
+/**
+ * `general` and `admin` are flagged `deprecated: true` in the base schema and
+ * still come back from the default list (no server-side filter equivalent —
+ * `deprecated[$ne]=true` doesn't take). Filter them out client-side.
+ */
+export declare function isDeprecatedRecord(record: SettingRecord): boolean;

package/dist/lib/inspect/settings.js

@@ -0,0 +1,56 @@
+const PATH_SEGMENT = /^[\w.-]+$/;
+const APP_PREFIX = /^app\.([^.]+)$/;
+export function parseSettingsKey(input) {
+    const appMatch = input.match(APP_PREFIX);
+    if (appMatch) {
+        return { kind: 'app', ref: appMatch[1] };
+    }
+    if (input.startsWith('app.')) {
+        return { kind: 'invalid', input };
+    }
+    if (PATH_SEGMENT.test(input)) {
+        return { kind: 'path', segment: input };
+    }
+    return { kind: 'invalid', input };
+}
+/**
+ * Produce the column-1 paste-back key for a settings record.
+ *
+ *   System (no app_id):  `record.name` (e.g. `taxes`).
+ *   App with slug:       `app.<slug>`.
+ *   App without slug:    `app.<hex>` (still pasteable — `app.<hex>` resolves).
+ *
+ * App records carry `name === app_id` (the hex), which is meaningless to a
+ * human; we never surface it. Ultimate fallback is `record.id` for degenerate
+ * records that have neither `app_id` nor `name`.
+ */
+export function formatSettingsKey(record, appSlugById) {
+    if (!record.app_id) {
+        return record.name ?? record.id ?? '-';
+    }
+    const slug = appSlugById[record.app_id] ?? record.app_id;
+    return `app.${slug}`;
+}
+/**
+ * Group a settings record. System rows (`app_id` null/undefined) belong to the
+ * platform and render under a `system` divider at the top, mirroring the
+ * notifications shape.
+ */
+export function groupSettingsRecord(record, appSlugById) {
+    if (!record.app_id) {
+        return { slug: '<system>', label: 'system', order: 0 };
+    }
+    const resolved = appSlugById[record.app_id];
+    if (!resolved) {
+        return { slug: '<not resolved>', order: 2 };
+    }
+    return { slug: resolved };
+}
+/**
+ * `general` and `admin` are flagged `deprecated: true` in the base schema and
+ * still come back from the default list (no server-side filter equivalent —
+ * `deprecated[$ne]=true` doesn't take). Filter them out client-side.
+ */
+export function isDeprecatedRecord(record) {
+    return record.deprecated === true;
+}

package/dist/lib/inspect/table.d.ts

@@ -0,0 +1,29 @@
+export interface GroupInfo {
+    /** Grouping identity. Rows with the same slug land in the same section. */
+    slug: string;
+    /** Divider text. Defaults to `slug` when omitted. */
+    label?: string;
+    /** Sort priority; lower renders first. Ties preserve insertion order. Default 1. */
+    order?: number;
+}
+export interface KeyMetaRow {
+    /** Paste-back identifier rendered as column 1. */
+    key: string;
+    /** Optional compact status string. Empty or undefined renders the key alone. */
+    meta?: string;
+    /** Optional group; when some rows carry one, multiple groups produce dividers. */
+    group?: GroupInfo;
+}
+/**
+ * Render a two-column list: paste-back key + optional compact meta string.
+ *
+ * - Rows with meta render as `  <key-padded>  <meta>`.
+ * - Rows without meta render as `  <key>` with no trailing whitespace.
+ * - Key column width is computed globally across all rows so meta columns
+ *   align vertically.
+ * - Rows with a `group` are collected into sections; sections are separated
+ *   by a blank line and a `── <label>` divider. Sections sort by `order`
+ *   (lower first), ties preserve insertion order. A single group collapses
+ *   to a flat listing.
+ */
+export declare function renderKeyMetaTable(rows: KeyMetaRow[]): string[];

package/dist/lib/inspect/table.js

@@ -0,0 +1,61 @@
+/**
+ * Render a two-column list: paste-back key + optional compact meta string.
+ *
+ * - Rows with meta render as `  <key-padded>  <meta>`.
+ * - Rows without meta render as `  <key>` with no trailing whitespace.
+ * - Key column width is computed globally across all rows so meta columns
+ *   align vertically.
+ * - Rows with a `group` are collected into sections; sections are separated
+ *   by a blank line and a `── <label>` divider. Sections sort by `order`
+ *   (lower first), ties preserve insertion order. A single group collapses
+ *   to a flat listing.
+ */
+export function renderKeyMetaTable(rows) {
+    if (rows.length === 0) {
+        return [];
+    }
+    const keyWidth = Math.max(...rows.map((r) => r.key.length));
+    const formatRow = (row) => {
+        if (row.meta && row.meta.length > 0) {
+            return `  ${row.key.padEnd(keyWidth)}  ${row.meta}`;
+        }
+        return `  ${row.key}`;
+    };
+    const hasGroups = rows.some((r) => r.group !== undefined);
+    if (!hasGroups) {
+        return rows.map((row) => formatRow(row));
+    }
+    const groupMap = new Map();
+    for (const row of rows) {
+        const info = row.group;
+        if (!info)
+            continue;
+        const existing = groupMap.get(info.slug);
+        if (existing) {
+            existing.rows.push(row);
+        }
+        else {
+            groupMap.set(info.slug, {
+                slug: info.slug,
+                label: info.label ?? info.slug,
+                order: info.order ?? 1,
+                rows: [row],
+            });
+        }
+    }
+    if (groupMap.size === 1) {
+        return rows.map((row) => formatRow(row));
+    }
+    const ordered = [...groupMap.values()].sort((a, b) => a.order - b.order);
+    const lines = [];
+    for (const group of ordered) {
+        if (lines.length > 0) {
+            lines.push('');
+        }
+        lines.push(`── ${group.label}`);
+        for (const row of group.rows) {
+            lines.push(formatRow(row));
+        }
+    }
+    return lines;
+}

package/dist/push-app-command.js

@@ -6,8 +6,9 @@ import * as path from 'node:path';
 import Stream from 'node:stream';
 import ora from 'ora';
 import { default as swellConfig } from './lib/app-config.js';
-import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, CUSTOM_FRAMEWORK_SLUG, appConfigFromFile, filePathExists, filePathExistsAsync, findAppConfig, getAppSlugId, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, getProjectCommands, globAllFilesByPath, hashString, isPathDirectory, } from './lib/apps/index.js';
+import { ConfigType, getFrontendProjectValidValues, allConfigFilesInDir, CUSTOM_FRAMEWORK_SLUG, appConfigFromFile, filePathExists, filePathExistsAsync, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, getFrontendProjectType, getProjectCommands, globAllFilesByPath, hashString, isPathDirectory, } from './lib/apps/index.js';
 import { getGlobIgnorePathsChecker } from './lib/apps/paths.js';
+import { slugFromApp } from './lib/apps/slug.js';
 import { default as localConfig } from './lib/config.js';
 import { toAppId } from './lib/create/index.js';
 import { detectPackageManager, transformCommand, } from './lib/package-manager.js';
@@ -139,7 +140,7 @@ export class PushAppCommand extends RemoteAppCommand {
         }
         const appSlugId = (await select({
             choices: apps.results.map((app) => ({
-                name: `${style.appConfigValue(app.name)} (${getAppSlugId(app)})`,
+                name: `${style.appConfigValue(app.name)} (${slugFromApp(app) ?? app.id})`,
                 value: app.private_id,
             })),
             message: `Choose ${typeLabelPrefixed} to pull`,

package/dist/swell-api-command.d.ts

@@ -6,10 +6,6 @@ export declare abstract class SwellApiCommand extends SwellCommand {
     protected request(command: typeof SwellApiCommand, requestOptions?: Api.RequestOptions): Promise<void>;
     protected catch(error: Error): Promise<any>;
     private parseCommand;
-    /**
-     * Resolve app ObjectId from a friendly slug or return as-is if already an ObjectId.
-     */
-    private resolveAppId;
     /**
      * Resolve function ID from app ID and function name.
      */

package/dist/swell-api-command.js

@@ -3,6 +3,7 @@ import * as fs from 'node:fs';
 import path from 'node:path';
 import { FetchError } from 'node-fetch';
 import { HttpMethod } from './lib/api.js';
+import { resolveAppId } from './lib/apps/resolve.js';
 import { SwellCommand } from './swell-command.js';
 // Pattern to match /functions/{appId}/{functionName} with optional query string
 const FUNCTION_PATH_REGEX = /^\/functions\/([^/]+)\/([^/?]+)(\?.*)?$/;
@@ -85,28 +86,11 @@ export class SwellApiCommand extends SwellCommand {
             },
         };
     }
-    /**
-     * Resolve app ObjectId from a friendly slug or return as-is if already an ObjectId.
-     */
-    async resolveAppId(appIdOrSlug) {
-        // If it looks like an ObjectId (24 hex chars), return as-is
-        if (/^[\da-f]{24}$/i.test(appIdOrSlug)) {
-            return appIdOrSlug;
-        }
-        // Fetch all installed apps and filter by public_id or private_id client-side
-        const installedApps = await this.api.get({ adminPath: `/client/apps` });
-        const app = installedApps?.results?.find((a) => a.app_public_id === appIdOrSlug ||
-            a.app_private_id === `_${appIdOrSlug}`);
-        if (!app) {
-            throw new Error(`App '${appIdOrSlug}' not found`);
-        }
-        return app.app_id;
-    }
     /**
      * Resolve function ID from app ID and function name.
      */
     async resolveFunctionId(appIdOrSlug, functionName) {
-        const appId = await this.resolveAppId(appIdOrSlug);
+        const appId = await resolveAppId(this.api, appIdOrSlug);
         const functionRecord = await this.api.get({ adminPath: `/data/:functions` }, {
             query: {
                 app_id: appId,