@ankhorage/studio 0.5.1 → 0.6.1

package/dist/host/layout/templates/auth/oauth.js

@@ -0,0 +1,268 @@
+import { escapeStringLiteral } from '../../utils/escapeStringLiteral';
+export function getAuthOAuthRuntimeTs(args) {
+    const callbackRoute = escapeStringLiteral(args.callbackRoute);
+    const providers = JSON.stringify(args.providers);
+    return `import type {
+  AuthOAuthCompletionResult,
+  AuthOAuthProviderId,
+  AuthOAuthTransportCancellationReason,
+} from '@ankhorage/contracts/auth';
+import * as Linking from 'expo-linking';
+import * as WebBrowser from 'expo-web-browser';
+import { Platform } from 'react-native';
+
+import { authAdapter } from './adapter';
+import {
+  authSessionStorage,
+  getStoredAuthSession,
+} from './session';
+
+const OAUTH_CALLBACK_ROUTE = '${callbackRoute}';
+const OAUTH_TRANSPORT_ATTEMPT_KEY = 'ankh.auth.oauth.transport.v1';
+const GENERATED_OAUTH_PROVIDERS = ${providers} as const;
+
+export const generatedOAuthProviderItems = GENERATED_OAUTH_PROVIDERS.map((provider) => ({
+  id: provider.id,
+  label: provider.label,
+  ...(provider.icon ? { icon: provider.icon } : {}),
+}));
+
+export type GeneratedOAuthTransportOutcome =
+  | { status: 'authenticated' }
+  | { status: 'cancelled'; message: string }
+  | { status: 'error'; message: string; recoverable: boolean };
+
+interface StoredTransportAttempt {
+  attemptId: string;
+  provider: AuthOAuthProviderId;
+  redirectUri: string;
+}
+
+let activeAuthorization: Promise<GeneratedOAuthTransportOutcome> | null = null;
+
+export function startOAuthAuthorization(
+  providerId: string,
+): Promise<GeneratedOAuthTransportOutcome> {
+  activeAuthorization ??= runOAuthAuthorization(providerId).finally(() => {
+    activeAuthorization = null;
+  });
+  return activeAuthorization;
+}
+
+async function runOAuthAuthorization(
+  providerId: string,
+): Promise<GeneratedOAuthTransportOutcome> {
+  const oauth = authAdapter.oauth;
+  if (!oauth) {
+    return {
+      status: 'error',
+      message: 'OAuth is not available in this app configuration.',
+      recoverable: true,
+    };
+  }
+
+  const provider = GENERATED_OAUTH_PROVIDERS.find((entry) => entry.id === providerId);
+  if (!provider) {
+    return {
+      status: 'error',
+      message: 'This OAuth provider is not enabled.',
+      recoverable: true,
+    };
+  }
+
+  const redirectUri = resolveOAuthRedirectUri();
+  const started = await oauth.startAuthorization({
+    provider: provider.id,
+    redirectUri,
+    scopes: provider.scopes,
+    queryParams: provider.queryParams,
+  });
+  if (!started.ok) {
+    return {
+      status: 'error',
+      message: started.error.message,
+      recoverable: started.error.recoverable,
+    };
+  }
+
+  try {
+    await writeTransportAttempt({
+      attemptId: started.data.attemptId,
+      provider: started.data.provider,
+      redirectUri: started.data.redirectUri,
+    });
+  } catch {
+    await cancelOAuthAttempt(started.data.attemptId, 'user_cancelled');
+    await clearTransportAttempt();
+    return {
+      status: 'error',
+      message: 'The OAuth authorization attempt could not be persisted.',
+      recoverable: true,
+    };
+  }
+
+  let browserResult: WebBrowser.WebBrowserAuthSessionResult;
+  try {
+    browserResult = await WebBrowser.openAuthSessionAsync(
+      started.data.authorizationUrl,
+      started.data.redirectUri,
+    );
+  } catch {
+    await cancelOAuthAttempt(started.data.attemptId, 'browser_dismissed');
+    await clearTransportAttempt();
+    return {
+      status: 'error',
+      message: 'The system authentication browser could not be opened.',
+      recoverable: true,
+    };
+  }
+
+  if (browserResult.type === 'success' && typeof browserResult.url === 'string') {
+    return completeOAuthCallback(browserResult.url);
+  }
+
+  const cancellationReason =
+    browserResult.type === 'dismiss' ? 'browser_dismissed' : 'user_cancelled';
+  const completed = await oauth.completeAuthorization({
+    attemptId: started.data.attemptId,
+    response: { type: 'cancelled', reason: cancellationReason },
+  });
+  await clearTransportAttempt();
+  return toTransportOutcome(completed);
+}
+
+export async function completeOAuthCallback(
+  callbackUrl: string,
+): Promise<GeneratedOAuthTransportOutcome> {
+  const oauth = authAdapter.oauth;
+  if (!oauth) {
+    return {
+      status: 'error',
+      message: 'OAuth is not available in this app configuration.',
+      recoverable: true,
+    };
+  }
+
+  const attempt = await readTransportAttempt();
+  if (!attempt) {
+    return {
+      status: 'error',
+      message: 'The OAuth authorization attempt was not found or has expired.',
+      recoverable: true,
+    };
+  }
+
+  const completed = await oauth.completeAuthorization({
+    attemptId: attempt.attemptId,
+    response: { type: 'callback', url: callbackUrl },
+  });
+  await clearTransportAttempt();
+
+  if (
+    !completed.ok &&
+    completed.status === 'error' &&
+    completed.error.code === 'callback_already_completed' &&
+    getStoredAuthSession()
+  ) {
+    return { status: 'authenticated' };
+  }
+
+  return toTransportOutcome(completed);
+}
+
+function resolveOAuthRedirectUri(): string {
+  const callbackPath = OAUTH_CALLBACK_ROUTE.replace(/^\/+/, '');
+  if (Platform.OS === 'web') {
+    const location = Reflect.get(globalThis, 'location');
+    if (
+      typeof location === 'object' &&
+      location !== null &&
+      typeof Reflect.get(location, 'origin') === 'string'
+    ) {
+      return new URL(\`/\${callbackPath}\`, Reflect.get(location, 'origin')).toString();
+    }
+    throw new Error('Web OAuth requires a canonical browser origin.');
+  }
+
+  return Linking.createURL(callbackPath);
+}
+
+function toTransportOutcome(
+  result: AuthOAuthCompletionResult,
+): GeneratedOAuthTransportOutcome {
+  if (result.ok) {
+    return { status: 'authenticated' };
+  }
+  if (result.status === 'cancelled') {
+    return {
+      status: 'cancelled',
+      message:
+        result.reason === 'provider_denied'
+          ? 'Authorization was declined by the provider.'
+          : 'Authorization was cancelled.',
+    };
+  }
+  return {
+    status: 'error',
+    message: result.error.message,
+    recoverable: result.error.recoverable,
+  };
+}
+
+async function cancelOAuthAttempt(
+  attemptId: string,
+  reason: AuthOAuthTransportCancellationReason,
+): Promise<void> {
+  const oauth = authAdapter.oauth;
+  if (!oauth) return;
+  try {
+    await oauth.completeAuthorization({
+      attemptId,
+      response: { type: 'cancelled', reason },
+    });
+  } catch {
+    // Best-effort cleanup must not replace the original transport error.
+  }
+}
+
+async function writeTransportAttempt(attempt: StoredTransportAttempt): Promise<void> {
+  await authSessionStorage.setItem(OAUTH_TRANSPORT_ATTEMPT_KEY, JSON.stringify(attempt));
+}
+
+async function readTransportAttempt(): Promise<StoredTransportAttempt | null> {
+  const raw = await authSessionStorage.getItem(OAUTH_TRANSPORT_ATTEMPT_KEY);
+  if (!raw) return null;
+  try {
+    const value: unknown = JSON.parse(raw);
+    if (!isRecord(value)) return null;
+    const attemptId = Reflect.get(value, 'attemptId');
+    const provider = Reflect.get(value, 'provider');
+    const redirectUri = Reflect.get(value, 'redirectUri');
+    const configuredProvider =
+      typeof provider === 'string'
+        ? GENERATED_OAUTH_PROVIDERS.find((entry) => entry.id === provider)
+        : undefined;
+    return typeof attemptId === 'string' &&
+      configuredProvider !== undefined &&
+      typeof redirectUri === 'string'
+      ? { attemptId, provider: configuredProvider.id, redirectUri }
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+async function clearTransportAttempt(): Promise<void> {
+  try {
+    await authSessionStorage.removeItem(OAUTH_TRANSPORT_ATTEMPT_KEY);
+  } catch {
+    // Cleanup failures are intentionally not surfaced with persisted state.
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+`;
+}
+//# sourceMappingURL=oauth.js.map

package/dist/host/layout/templates/auth/oauth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.js","sourceRoot":"","sources":["../../../../../src/host/layout/templates/auth/oauth.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAEtE,MAAM,UAAU,qBAAqB,CAAC,IAAyB;IAC7D,MAAM,aAAa,GAAG,mBAAmB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC9D,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAEjD,OAAO;;;;;;;;;;;;;;;gCAeuB,aAAa;;oCAET,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoP5C,CAAC;AACF,CAAC"}

package/dist/host/layout/templates/auth/screen.d.ts

@@ -1,12 +1,15 @@
+import type { GeneratedOAuthProviderPlan } from '../../auth/resolveAuthLayoutPlan';
 export declare function getAuthScreenTsx(args: {
     initialMode: 'signIn' | 'signUp';
     screenName: string;
     title?: string;
     signInRoute: string;
     signUpRoute: string;
+    postSignInRoute: string;
     signInIdentifiers: string[];
     signUpRequiredFields: string[];
     signUpOptionalFields: string[];
     signUpPolicy: 'autoSignIn' | 'requireVerification';
+    oauthProviders?: readonly GeneratedOAuthProviderPlan[];
 }): string;
 //# sourceMappingURL=screen.d.ts.map

package/dist/host/layout/templates/auth/screen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../../../../src/host/layout/templates/auth/screen.ts"],"names":[],"mappings":"AAWA,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,WAAW,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,YAAY,EAAE,YAAY,GAAG,qBAAqB,CAAC;CACpD,UA0oBA"}
+{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../../../../src/host/layout/templates/auth/screen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAYnF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,WAAW,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,YAAY,EAAE,YAAY,GAAG,qBAAqB,CAAC;IACnD,cAAc,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;CACxD,UAipBA"}