shopify 3.93.1 → 3.94.0

package/dist/cli/services/store/auth/result.d.ts

@@ -1,24 +0,0 @@
-export interface StoreAuthResult {
-    store: string;
-    userId: string;
-    scopes: string[];
-    acquiredAt: string;
-    expiresAt?: string;
-    refreshTokenExpiresAt?: string;
-    hasRefreshToken: boolean;
-    associatedUser?: {
-        id: number;
-        email?: string;
-        firstName?: string;
-        lastName?: string;
-        accountOwner?: boolean;
-    };
-}
-type StoreAuthOutputFormat = 'text' | 'json';
-export interface StoreAuthPresenter {
-    openingBrowser: () => void;
-    manualAuthUrl: (authorizationUrl: string) => void;
-    success: (result: StoreAuthResult) => void;
-}
-export declare function createStoreAuthPresenter(format?: StoreAuthOutputFormat): StoreAuthPresenter;
-export {};

package/dist/cli/services/store/auth/result.js

@@ -1,39 +0,0 @@
-import { outputCompleted, outputInfo, outputResult, outputToken, outputContent } from '@shopify/cli-kit/node/output';
-function serializeStoreAuthResult(result) {
-    return JSON.stringify(result, null, 2);
-}
-function buildStoreAuthSuccessText(result) {
-    const displayName = result.associatedUser?.email ? ` as ${result.associatedUser.email}` : '';
-    return {
-        completed: ['Logged in.', `Authenticated${displayName} against ${result.store}.`],
-        info: ['', 'To verify that authentication worked, run:', `shopify store execute --store ${result.store} --query 'query { shop { name id } }'`],
-    };
-}
-function displayStoreAuthOpeningBrowser() {
-    outputInfo('Shopify CLI will open the app authorization page in your browser.');
-    outputInfo('');
-}
-function displayStoreAuthManualAuthUrl(authorizationUrl) {
-    outputInfo('Browser did not open automatically. Open this URL manually:');
-    outputInfo(outputContent `${outputToken.link(authorizationUrl)}`);
-    outputInfo('');
-}
-function displayStoreAuthResult(result, format = 'text') {
-    if (format === 'json') {
-        outputResult(serializeStoreAuthResult(result));
-        return;
-    }
-    const text = buildStoreAuthSuccessText(result);
-    text.completed.forEach((line) => outputCompleted(line));
-    text.info.forEach((line) => outputInfo(line));
-}
-export function createStoreAuthPresenter(format = 'text') {
-    return {
-        openingBrowser: displayStoreAuthOpeningBrowser,
-        manualAuthUrl: displayStoreAuthManualAuthUrl,
-        success(result) {
-            displayStoreAuthResult(result, format);
-        },
-    };
-}
-//# sourceMappingURL=result.js.map

package/dist/cli/services/store/auth/scopes.d.ts

@@ -1,4 +0,0 @@
-import type { StoreTokenResponse } from './token-client.js';
-export declare function parseStoreAuthScopes(input: string): string[];
-export declare function mergeRequestedAndStoredScopes(requestedScopes: string[], storedScopes: string[]): string[];
-export declare function resolveGrantedScopes(tokenResponse: StoreTokenResponse, requestedScopes: string[]): string[];

package/dist/cli/services/store/auth/scopes.js

@@ -1,53 +0,0 @@
-import { AbortError } from '@shopify/cli-kit/node/error';
-import { outputContent, outputDebug } from '@shopify/cli-kit/node/output';
-export function parseStoreAuthScopes(input) {
-    const scopes = input
-        .split(',')
-        .map((scope) => scope.trim())
-        .filter(Boolean);
-    if (scopes.length === 0) {
-        throw new AbortError('At least one scope is required.', 'Pass --scopes as a comma-separated list.');
-    }
-    return [...new Set(scopes)];
-}
-function expandImpliedStoreScopes(scopes) {
-    const expandedScopes = new Set(scopes);
-    for (const scope of scopes) {
-        const matches = scope.match(/^(unauthenticated_)?write_(.*)$/);
-        if (matches) {
-            expandedScopes.add(`${matches[1] ?? ''}read_${matches[2]}`);
-        }
-    }
-    return expandedScopes;
-}
-export function mergeRequestedAndStoredScopes(requestedScopes, storedScopes) {
-    const mergedScopes = [...storedScopes];
-    const expandedScopes = expandImpliedStoreScopes(storedScopes);
-    for (const scope of requestedScopes) {
-        if (expandedScopes.has(scope))
-            continue;
-        mergedScopes.push(scope);
-        for (const expandedScope of expandImpliedStoreScopes([scope])) {
-            expandedScopes.add(expandedScope);
-        }
-    }
-    return mergedScopes;
-}
-export function resolveGrantedScopes(tokenResponse, requestedScopes) {
-    if (!tokenResponse.scope) {
-        outputDebug(outputContent `Token response did not include scope; falling back to requested scopes`);
-        return requestedScopes;
-    }
-    const grantedScopes = parseStoreAuthScopes(tokenResponse.scope);
-    const expandedGrantedScopes = expandImpliedStoreScopes(grantedScopes);
-    const missingScopes = requestedScopes.filter((scope) => !expandedGrantedScopes.has(scope));
-    if (missingScopes.length > 0) {
-        throw new AbortError('Shopify granted fewer scopes than were requested.', `Missing scopes: ${missingScopes.join(', ')}.`, [
-            'Update the app or store installation scopes.',
-            'See https://shopify.dev/app/scopes',
-            'Re-run shopify store auth.',
-        ]);
-    }
-    return grantedScopes;
-}
-//# sourceMappingURL=scopes.js.map

package/dist/cli/services/store/auth/session-lifecycle.d.ts

@@ -1,3 +0,0 @@
-import type { StoredStoreAppSession } from './session-store.js';
-export declare function isSessionExpired(session: StoredStoreAppSession): boolean;
-export declare function loadStoredStoreSession(store: string): Promise<StoredStoreAppSession>;

package/dist/cli/services/store/auth/session-lifecycle.js

@@ -1,69 +0,0 @@
-import { AbortError } from '@shopify/cli-kit/node/error';
-import { outputContent, outputDebug, outputToken } from '@shopify/cli-kit/node/output';
-import { maskToken } from './config.js';
-import { createStoredStoreAuthError, reauthenticateStoreAuthError } from './recovery.js';
-import { clearStoredStoreAppSession, getCurrentStoredStoreAppSession, setStoredStoreAppSession, } from './session-store.js';
-import { refreshStoreAccessToken } from './token-client.js';
-const EXPIRY_MARGIN_MS = 4 * 60 * 1000;
-export function isSessionExpired(session) {
-    if (!session.expiresAt)
-        return false;
-    const expiresAtMs = new Date(session.expiresAt).getTime();
-    if (Number.isNaN(expiresAtMs))
-        return true;
-    return expiresAtMs - EXPIRY_MARGIN_MS < Date.now();
-}
-function buildRefreshedStoredSession(session, refresh) {
-    const now = Date.now();
-    const expiresAt = refresh.expiresIn ? new Date(now + refresh.expiresIn * 1000).toISOString() : session.expiresAt;
-    return {
-        ...session,
-        accessToken: refresh.accessToken,
-        refreshToken: refresh.refreshToken ?? session.refreshToken,
-        expiresAt,
-        refreshTokenExpiresAt: refresh.refreshTokenExpiresIn
-            ? new Date(now + refresh.refreshTokenExpiresIn * 1000).toISOString()
-            : session.refreshTokenExpiresAt,
-        acquiredAt: new Date(now).toISOString(),
-    };
-}
-export async function loadStoredStoreSession(store) {
-    let session = getCurrentStoredStoreAppSession(store);
-    if (!session) {
-        throw createStoredStoreAuthError(store);
-    }
-    outputDebug(outputContent `Loaded stored session for ${outputToken.raw(store)}: token=${outputToken.raw(maskToken(session.accessToken))}, expires=${outputToken.raw(session.expiresAt ?? 'unknown')}`);
-    if (!isSessionExpired(session)) {
-        return session;
-    }
-    if (!session.refreshToken) {
-        throw reauthenticateStoreAuthError(`No refresh token stored for ${session.store}.`, session.store, session.scopes.join(','));
-    }
-    outputDebug(outputContent `Refreshing expired token for ${outputToken.raw(session.store)} (expired at ${outputToken.raw(session.expiresAt ?? 'unknown')}, refresh_token=${outputToken.raw(maskToken(session.refreshToken))})`);
-    const previousAccessToken = session.accessToken;
-    let refreshed;
-    try {
-        refreshed = await refreshStoreAccessToken({
-            store: session.store,
-            refreshToken: session.refreshToken,
-        });
-    }
-    catch (error) {
-        clearStoredStoreAppSession(session.store, session.userId);
-        if (error instanceof AbortError && error.message.startsWith(`Token refresh failed for ${session.store} (HTTP `)) {
-            throw reauthenticateStoreAuthError(error.message, session.store, session.scopes.join(','));
-        }
-        if (error instanceof AbortError && error.message === `Token refresh returned an invalid response for ${session.store}.`) {
-            throw reauthenticateStoreAuthError(error.message, session.store, session.scopes.join(','));
-        }
-        if (error instanceof AbortError && error.message === 'Received an invalid refresh response from Shopify.') {
-            throw error;
-        }
-        throw error;
-    }
-    session = buildRefreshedStoredSession(session, refreshed);
-    outputDebug(outputContent `Token refresh succeeded for ${outputToken.raw(session.store)}: ${outputToken.raw(maskToken(previousAccessToken))} → ${outputToken.raw(maskToken(session.accessToken))}, new expiry ${outputToken.raw(session.expiresAt ?? 'unknown')}`);
-    setStoredStoreAppSession(session);
-    return session;
-}
-//# sourceMappingURL=session-lifecycle.js.map

package/dist/cli/services/store/auth/session-store.d.ts

@@ -1,32 +0,0 @@
-import { LocalStorage } from '@shopify/cli-kit/node/local-storage';
-export interface StoredStoreAppSession {
-    store: string;
-    clientId: string;
-    userId: string;
-    accessToken: string;
-    refreshToken?: string;
-    scopes: string[];
-    acquiredAt: string;
-    expiresAt?: string;
-    refreshTokenExpiresAt?: string;
-    associatedUser?: {
-        id: number;
-        email?: string;
-        firstName?: string;
-        lastName?: string;
-        accountOwner?: boolean;
-    };
-}
-interface StoredStoreAppSessionBucket {
-    currentUserId: string;
-    sessionsByUserId: {
-        [userId: string]: StoredStoreAppSession;
-    };
-}
-interface StoreSessionSchema {
-    [key: string]: StoredStoreAppSessionBucket;
-}
-export declare function getCurrentStoredStoreAppSession(store: string, storage?: LocalStorage<StoreSessionSchema>): StoredStoreAppSession | undefined;
-export declare function setStoredStoreAppSession(session: StoredStoreAppSession, storage?: LocalStorage<StoreSessionSchema>): void;
-export declare function clearStoredStoreAppSession(store: string, userIdOrStorage?: string | LocalStorage<StoreSessionSchema>, maybeStorage?: LocalStorage<StoreSessionSchema>): void;
-export {};

package/dist/cli/services/store/auth/session-store.js

@@ -1,127 +0,0 @@
-import { LocalStorage } from '@shopify/cli-kit/node/local-storage';
-import { storeAuthSessionKey } from './config.js';
-let _storeSessionStorage;
-function storeSessionStorage() {
-    _storeSessionStorage ?? (_storeSessionStorage = new LocalStorage({ projectName: 'shopify-cli-store' }));
-    return _storeSessionStorage;
-}
-function isString(value) {
-    return typeof value === 'string';
-}
-function sanitizeAssociatedUser(value) {
-    if (!value || typeof value !== 'object')
-        return undefined;
-    const associatedUser = value;
-    if (typeof associatedUser.id !== 'number')
-        return undefined;
-    return {
-        id: associatedUser.id,
-        ...(isString(associatedUser.email) ? { email: associatedUser.email } : {}),
-        ...(isString(associatedUser.firstName) ? { firstName: associatedUser.firstName } : {}),
-        ...(isString(associatedUser.lastName) ? { lastName: associatedUser.lastName } : {}),
-        ...(typeof associatedUser.accountOwner === 'boolean' ? { accountOwner: associatedUser.accountOwner } : {}),
-    };
-}
-function sanitizeStoredStoreAppSession(value) {
-    if (!value || typeof value !== 'object')
-        return undefined;
-    const session = value;
-    if (!isString(session.store) ||
-        !isString(session.clientId) ||
-        !isString(session.userId) ||
-        !isString(session.accessToken) ||
-        !Array.isArray(session.scopes) ||
-        !session.scopes.every(isString) ||
-        !isString(session.acquiredAt)) {
-        return undefined;
-    }
-    return {
-        store: session.store,
-        clientId: session.clientId,
-        userId: session.userId,
-        accessToken: session.accessToken,
-        scopes: session.scopes,
-        acquiredAt: session.acquiredAt,
-        ...(isString(session.refreshToken) ? { refreshToken: session.refreshToken } : {}),
-        ...(isString(session.expiresAt) ? { expiresAt: session.expiresAt } : {}),
-        ...(isString(session.refreshTokenExpiresAt) ? { refreshTokenExpiresAt: session.refreshTokenExpiresAt } : {}),
-        ...(sanitizeAssociatedUser(session.associatedUser) ? { associatedUser: sanitizeAssociatedUser(session.associatedUser) } : {}),
-    };
-}
-function readStoredStoreAppSessionBucket(store, storage) {
-    const key = storeAuthSessionKey(store);
-    const storedBucket = storage.get(key);
-    if (!storedBucket || typeof storedBucket !== 'object')
-        return undefined;
-    const { sessionsByUserId, currentUserId } = storedBucket;
-    if (!sessionsByUserId || typeof sessionsByUserId !== 'object' || Array.isArray(sessionsByUserId) || typeof currentUserId !== 'string') {
-        storage.delete(key);
-        return undefined;
-    }
-    const sanitizedSessionsByUserId = Object.fromEntries(Object.entries(sessionsByUserId).flatMap(([userId, session]) => {
-        const sanitizedSession = sanitizeStoredStoreAppSession(session);
-        return sanitizedSession ? [[userId, sanitizedSession]] : [];
-    }));
-    if (Object.keys(sanitizedSessionsByUserId).length !== Object.keys(sessionsByUserId).length) {
-        if (sanitizedSessionsByUserId[currentUserId]) {
-            storage.set(key, {
-                currentUserId,
-                sessionsByUserId: sanitizedSessionsByUserId,
-            });
-        }
-        else {
-            storage.delete(key);
-            return undefined;
-        }
-    }
-    return {
-        currentUserId,
-        sessionsByUserId: sanitizedSessionsByUserId,
-    };
-}
-export function getCurrentStoredStoreAppSession(store, storage = storeSessionStorage()) {
-    const bucket = readStoredStoreAppSessionBucket(store, storage);
-    if (!bucket)
-        return undefined;
-    const session = bucket.sessionsByUserId[bucket.currentUserId];
-    if (!session) {
-        storage.delete(storeAuthSessionKey(store));
-        return undefined;
-    }
-    return session;
-}
-export function setStoredStoreAppSession(session, storage = storeSessionStorage()) {
-    const key = storeAuthSessionKey(session.store);
-    const existingBucket = readStoredStoreAppSessionBucket(session.store, storage);
-    const nextBucket = {
-        currentUserId: session.userId,
-        sessionsByUserId: {
-            ...(existingBucket?.sessionsByUserId ?? {}),
-            [session.userId]: session,
-        },
-    };
-    storage.set(key, nextBucket);
-}
-export function clearStoredStoreAppSession(store, userIdOrStorage, maybeStorage) {
-    const userId = typeof userIdOrStorage === 'string' ? userIdOrStorage : undefined;
-    const storage = (typeof userIdOrStorage === 'string' ? maybeStorage : userIdOrStorage) ?? storeSessionStorage();
-    const key = storeAuthSessionKey(store);
-    if (!userId) {
-        storage.delete(key);
-        return;
-    }
-    const existingBucket = readStoredStoreAppSessionBucket(store, storage);
-    if (!existingBucket)
-        return;
-    const { [userId]: _removedSession, ...remainingSessions } = existingBucket.sessionsByUserId;
-    const remainingUserIds = Object.keys(remainingSessions);
-    if (remainingUserIds.length === 0) {
-        storage.delete(key);
-        return;
-    }
-    storage.set(key, {
-        currentUserId: existingBucket.currentUserId === userId ? remainingUserIds[0] : existingBucket.currentUserId,
-        sessionsByUserId: remainingSessions,
-    });
-}
-//# sourceMappingURL=session-store.js.map

package/dist/cli/services/store/auth/token-client.d.ts

@@ -1,40 +0,0 @@
-export interface StoreTokenResponse {
-    access_token: string;
-    token_type?: string;
-    scope?: string;
-    expires_in?: number;
-    refresh_token?: string;
-    refresh_token_expires_in?: number;
-    associated_user_scope?: string;
-    associated_user?: {
-        id: number;
-        first_name?: string;
-        last_name?: string;
-        email?: string;
-        account_owner?: boolean;
-        locale?: string;
-        collaborator?: boolean;
-        email_verified?: boolean;
-    };
-}
-interface StoreTokenRefreshPayload {
-    accessToken: string;
-    refreshToken?: string;
-    expiresIn?: number;
-    refreshTokenExpiresIn?: number;
-}
-export declare function exchangeStoreAuthCodeForToken(options: {
-    store: string;
-    code: string;
-    codeVerifier: string;
-    redirectUri: string;
-}): Promise<StoreTokenResponse>;
-export declare function refreshStoreAccessToken(options: {
-    store: string;
-    refreshToken: string;
-}): Promise<StoreTokenRefreshPayload>;
-export declare function fetchCurrentStoreAuthScopes(options: {
-    store: string;
-    accessToken: string;
-}): Promise<string[]>;
-export {};

package/dist/cli/services/store/auth/token-client.js

@@ -1,95 +0,0 @@
-import { adminUrl } from '@shopify/cli-kit/node/api/admin';
-import { graphqlRequest } from '@shopify/cli-kit/node/api/graphql';
-import { AbortError } from '@shopify/cli-kit/node/error';
-import { fetch } from '@shopify/cli-kit/node/http';
-import { outputContent, outputDebug, outputToken } from '@shopify/cli-kit/node/output';
-import { maskToken, STORE_AUTH_APP_CLIENT_ID } from './config.js';
-function truncateHttpErrorBody(body, length = 300) {
-    return body.slice(0, length);
-}
-export async function exchangeStoreAuthCodeForToken(options) {
-    const endpoint = `https://${options.store}/admin/oauth/access_token`;
-    outputDebug(outputContent `Exchanging authorization code for token at ${outputToken.raw(endpoint)}`);
-    const response = await fetch(endpoint, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            client_id: STORE_AUTH_APP_CLIENT_ID,
-            code: options.code,
-            code_verifier: options.codeVerifier,
-            redirect_uri: options.redirectUri,
-        }),
-    });
-    const body = await response.text();
-    if (!response.ok) {
-        outputDebug(outputContent `Token exchange failed with HTTP ${outputToken.raw(String(response.status))}: ${outputToken.raw(truncateHttpErrorBody(body || response.statusText))}`);
-        throw new AbortError(`Failed to exchange OAuth code for an access token (HTTP ${response.status}).`, body || response.statusText);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(body);
-    }
-    catch {
-        throw new AbortError('Received an invalid token response from Shopify.');
-    }
-    outputDebug(outputContent `Token exchange succeeded: access_token=${outputToken.raw(maskToken(parsed.access_token))}, refresh_token=${outputToken.raw(parsed.refresh_token ? maskToken(parsed.refresh_token) : 'none')}, expires_in=${outputToken.raw(String(parsed.expires_in ?? 'unknown'))}s, user=${outputToken.raw(String(parsed.associated_user?.id ?? 'unknown'))} (${outputToken.raw(parsed.associated_user?.email ?? 'no email')})`);
-    return parsed;
-}
-export async function refreshStoreAccessToken(options) {
-    const endpoint = `https://${options.store}/admin/oauth/access_token`;
-    outputDebug(outputContent `Refreshing access token for ${outputToken.raw(options.store)} using refresh_token=${outputToken.raw(maskToken(options.refreshToken))}`);
-    const response = await fetch(endpoint, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            client_id: STORE_AUTH_APP_CLIENT_ID,
-            grant_type: 'refresh_token',
-            refresh_token: options.refreshToken,
-        }),
-    });
-    const body = await response.text();
-    if (!response.ok) {
-        outputDebug(outputContent `Token refresh failed with HTTP ${outputToken.raw(String(response.status))}: ${outputToken.raw(truncateHttpErrorBody(body || response.statusText))}`);
-        throw new AbortError(`Token refresh failed for ${options.store} (HTTP ${response.status}).`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(body);
-    }
-    catch {
-        throw new AbortError('Received an invalid refresh response from Shopify.');
-    }
-    if (!parsed.access_token) {
-        throw new AbortError(`Token refresh returned an invalid response for ${options.store}.`);
-    }
-    return {
-        accessToken: parsed.access_token,
-        refreshToken: parsed.refresh_token,
-        expiresIn: parsed.expires_in,
-        refreshTokenExpiresIn: parsed.refresh_token_expires_in,
-    };
-}
-const CurrentAppInstallationAccessScopesQuery = `#graphql
-  query CurrentAppInstallationAccessScopes {
-    currentAppInstallation {
-      accessScopes {
-        handle
-      }
-    }
-  }
-`;
-export async function fetchCurrentStoreAuthScopes(options) {
-    outputDebug(outputContent `Fetching current app installation scopes for ${outputToken.raw(options.store)} using token ${outputToken.raw(maskToken(options.accessToken))}`);
-    const data = await graphqlRequest({
-        query: CurrentAppInstallationAccessScopesQuery,
-        api: 'Admin',
-        url: adminUrl(options.store, 'unstable'),
-        token: options.accessToken,
-        responseOptions: { handleErrors: false },
-    });
-    if (!Array.isArray(data.currentAppInstallation?.accessScopes)) {
-        throw new Error('Shopify did not return currentAppInstallation.accessScopes.');
-    }
-    return data.currentAppInstallation.accessScopes.flatMap((scope) => typeof scope.handle === 'string' ? [scope.handle] : []);
-}
-//# sourceMappingURL=token-client.js.map

package/dist/cli/services/store/execute/admin-context.d.ts

@@ -1,11 +0,0 @@
-import type { AdminSession } from '@shopify/cli-kit/node/session';
-import type { StoredStoreAppSession } from '../auth/session-store.js';
-export interface AdminStoreGraphQLContext {
-    adminSession: AdminSession;
-    version: string;
-    session: StoredStoreAppSession;
-}
-export declare function prepareAdminStoreGraphQLContext(input: {
-    store: string;
-    userSpecifiedVersion?: string;
-}): Promise<AdminStoreGraphQLContext>;

package/dist/cli/services/store/execute/admin-context.js

@@ -1,41 +0,0 @@
-import { fetchApiVersions } from '@shopify/cli-kit/node/api/admin';
-import { AbortError } from '@shopify/cli-kit/node/error';
-import { reauthenticateStoreAuthError } from '../auth/recovery.js';
-import { clearStoredStoreAppSession } from '../auth/session-store.js';
-import { loadStoredStoreSession } from '../auth/session-lifecycle.js';
-async function resolveApiVersion(options) {
-    const { session, adminSession, userSpecifiedVersion } = options;
-    if (userSpecifiedVersion === 'unstable')
-        return userSpecifiedVersion;
-    let availableVersions;
-    try {
-        availableVersions = await fetchApiVersions(adminSession);
-    }
-    catch (error) {
-        if (error instanceof AbortError &&
-            error.message.includes(`Error connecting to your store ${adminSession.storeFqdn}:`) &&
-            /\b(?:401|404)\b/.test(error.message)) {
-            clearStoredStoreAppSession(session.store, session.userId);
-            throw reauthenticateStoreAuthError(`Stored app authentication for ${session.store} is no longer valid.`, session.store, session.scopes.join(','));
-        }
-        throw error;
-    }
-    if (!userSpecifiedVersion) {
-        const supportedVersions = availableVersions.filter((version) => version.supported).map((version) => version.handle);
-        return supportedVersions.sort().reverse()[0];
-    }
-    const versionList = availableVersions.map((version) => version.handle);
-    if (versionList.includes(userSpecifiedVersion))
-        return userSpecifiedVersion;
-    throw new AbortError(`Invalid API version: ${userSpecifiedVersion}`, `Allowed versions: ${versionList.join(', ')}`);
-}
-export async function prepareAdminStoreGraphQLContext(input) {
-    const session = await loadStoredStoreSession(input.store);
-    const adminSession = {
-        token: session.accessToken,
-        storeFqdn: session.store,
-    };
-    const version = await resolveApiVersion({ session, adminSession, userSpecifiedVersion: input.userSpecifiedVersion });
-    return { adminSession, version, session };
-}
-//# sourceMappingURL=admin-context.js.map

package/dist/cli/services/store/execute/admin-transport.d.ts

@@ -1,6 +0,0 @@
-import type { PreparedStoreExecuteRequest } from './request.js';
-import type { AdminStoreGraphQLContext } from './admin-context.js';
-export declare function runAdminStoreGraphQLOperation(input: {
-    context: AdminStoreGraphQLContext;
-    request: PreparedStoreExecuteRequest;
-}): Promise<unknown>;

package/dist/cli/services/store/execute/admin-transport.js

@@ -1,42 +0,0 @@
-import { adminUrl } from '@shopify/cli-kit/node/api/admin';
-import { graphqlRequest } from '@shopify/cli-kit/node/api/graphql';
-import { AbortError } from '@shopify/cli-kit/node/error';
-import { outputContent } from '@shopify/cli-kit/node/output';
-import { renderSingleTask } from '@shopify/cli-kit/node/ui';
-import { reauthenticateStoreAuthError } from '../auth/recovery.js';
-import { clearStoredStoreAppSession } from '../auth/session-store.js';
-function isGraphQLClientError(error) {
-    if (!error || typeof error !== 'object' || !('response' in error))
-        return false;
-    const response = error.response;
-    return !!response && typeof response === 'object';
-}
-export async function runAdminStoreGraphQLOperation(input) {
-    try {
-        return await renderSingleTask({
-            title: outputContent `Executing GraphQL operation`,
-            task: async () => {
-                return graphqlRequest({
-                    query: input.request.query,
-                    api: 'Admin',
-                    url: adminUrl(input.context.adminSession.storeFqdn, input.context.version, input.context.adminSession),
-                    token: input.context.adminSession.token,
-                    variables: input.request.parsedVariables,
-                    responseOptions: { handleErrors: false },
-                });
-            },
-            renderOptions: { stdout: process.stderr },
-        });
-    }
-    catch (error) {
-        if (isGraphQLClientError(error) && error.response.status === 401) {
-            clearStoredStoreAppSession(input.context.session.store, input.context.session.userId);
-            throw reauthenticateStoreAuthError(`Stored app authentication for ${input.context.session.store} is no longer valid.`, input.context.session.store, input.context.session.scopes.join(','));
-        }
-        if (isGraphQLClientError(error) && error.response.errors) {
-            throw new AbortError('GraphQL operation failed.', JSON.stringify({ errors: error.response.errors }, null, 2));
-        }
-        throw error;
-    }
-}
-//# sourceMappingURL=admin-transport.js.map

package/dist/cli/services/store/execute/index.d.ts

@@ -1,13 +0,0 @@
-import { type StoreGraphQLApi } from './targets.js';
-interface ExecuteStoreOperationInput {
-    store: string;
-    api?: StoreGraphQLApi;
-    query?: string;
-    queryFile?: string;
-    variables?: string;
-    variableFile?: string;
-    version?: string;
-    allowMutations?: boolean;
-}
-export declare function executeStoreOperation(input: ExecuteStoreOperationInput): Promise<unknown>;
-export {};

package/dist/cli/services/store/execute/index.js

@@ -1,22 +0,0 @@
-import { renderSingleTask } from '@shopify/cli-kit/node/ui';
-import { outputContent } from '@shopify/cli-kit/node/output';
-import { prepareStoreExecuteRequest } from './request.js';
-import { getStoreGraphQLTarget } from './targets.js';
-export async function executeStoreOperation(input) {
-    const target = getStoreGraphQLTarget(input.api ?? 'admin');
-    const request = await prepareStoreExecuteRequest({
-        query: input.query,
-        queryFile: input.queryFile,
-        variables: input.variables,
-        variableFile: input.variableFile,
-        version: input.version,
-        allowMutations: input.allowMutations,
-    });
-    const context = await renderSingleTask({
-        title: outputContent `Loading stored store auth`,
-        task: async () => target.prepareContext({ store: input.store, requestedVersion: request.requestedVersion }),
-        renderOptions: { stdout: process.stderr },
-    });
-    return await target.execute({ context, request });
-}
-//# sourceMappingURL=index.js.map

package/dist/cli/services/store/execute/request.d.ts

@@ -1,21 +0,0 @@
-import { OperationDefinitionNode } from 'graphql';
-interface ParsedGraphQLOperation {
-    operationDefinition: OperationDefinitionNode;
-}
-export interface PreparedStoreExecuteRequest {
-    query: string;
-    parsedOperation: ParsedGraphQLOperation;
-    parsedVariables?: {
-        [key: string]: unknown;
-    };
-    requestedVersion?: string;
-}
-export declare function prepareStoreExecuteRequest(input: {
-    query?: string;
-    queryFile?: string;
-    variables?: string;
-    variableFile?: string;
-    version?: string;
-    allowMutations?: boolean;
-}): Promise<PreparedStoreExecuteRequest>;
-export {};