convex 1.42.2 → 1.43.0-alpha.0

package/src/cli/generatedApi.ts

@@ -301,22 +301,22 @@ export interface components {
             usedEmails: string[];
         };
         CheckProjectEnvironmentHealthRequest: {
-            /** @description WorkOS client ID */
-            clientId: string;
             /**
              * Format: int64
              * @description Project ID
              */
             projectId: number;
+            /** @description WorkOS client ID */
+            clientId: string;
         };
         DeleteProjectEnvironmentRequest: {
-            /** @description WorkOS client ID of the environment to delete */
-            clientId: string;
             /**
              * Format: int64
              * @description Project ID for the environment to delete
              */
             projectId: number;
+            /** @description WorkOS client ID of the environment to delete */
+            clientId: string;
         };
         /** @description Response for deleting a project environment - matches
          *     DeleteWorkOSEnvironmentResponse */
@@ -350,13 +350,13 @@ export interface components {
         /** @description Response for getting a project WorkOS environment with credentials - matches
          *     ProvisionProjectEnvironmentResponse pattern with workos_ prefix */
         GetProjectEnvironmentResponse: {
-            isProduction: boolean;
-            /** @description The user-provided environment name (e.g., "staging", "development") */
-            userEnvironmentName: string;
-            workosApiKey: string;
-            workosClientId: string;
             workosEnvironmentId: string;
             workosEnvironmentName: string;
+            workosClientId: string;
+            workosApiKey: string;
+            /** @description The user-provided environment name (e.g., "staging", "development") */
+            userEnvironmentName: string;
+            isProduction: boolean;
         };
         GetProjectEnvironmentsResponse: {
             environments: components["schemas"]["ProjectEnvironmentSummary"][];
@@ -365,31 +365,31 @@ export interface components {
             deploymentName: string;
         };
         HasAssociatedWorkOSTeamResponse: {
-            /** @description Email of Convex team member who created the WorkOS account.
-             *     This field should always be present when has_associated_workos_team is
-             *     true. */
-            adminConvexEmail?: string | null;
+            hasAssociatedWorkosTeam: boolean;
+            teamId: components["schemas"]["TeamId"];
             /** @description Email address used to provision the WorkOS account. This field should
              *     always be present if has_associated_workos_team is true. */
             adminEmail?: string | null;
             /** @description Name of Convex team member who created the WorkOS account.
              *     This field is optional even when has_associated_workos_team is true. */
             adminName?: string | null;
-            hasAssociatedWorkosTeam: boolean;
-            teamId: components["schemas"]["TeamId"];
+            /** @description Email of Convex team member who created the WorkOS account.
+             *     This field should always be present when has_associated_workos_team is
+             *     true. */
+            adminConvexEmail?: string | null;
         };
         InvitationEligibleEmailsResponse: {
+            eligibleEmails: string[];
             /** @description The admin email used to create this team's WorkOS account (always
              *     eligible for re-invitation) */
             adminEmail?: string | null;
-            eligibleEmails: string[];
         };
         InviteWorkOSTeamMemberRequest: {
+            /** @description Convex team ID that has an associated WorkOS team */
+            teamId: components["schemas"]["TeamId"];
             /** @description Email address to invite to the WorkOS team,
              *     must be a verified email address associated with the user's account */
             email: string;
-            /** @description Convex team ID that has an associated WorkOS team */
-            teamId: components["schemas"]["TeamId"];
         };
         InviteWorkOSTeamMemberResponse: {
             email: string;
@@ -401,35 +401,35 @@ export interface components {
         /** Format: int64 */
         MemberId: number;
         ProjectDetails: {
-            /** Format: int64 */
-            createTime: number;
-            devDeploymentName?: string | null;
             id: components["schemas"]["ProjectId"];
             name: components["schemas"]["ProjectName"];
-            prodDeploymentName?: string | null;
             slug: components["schemas"]["ProjectSlug"];
             teamId: components["schemas"]["TeamId"];
+            /** Format: int64 */
+            createTime: number;
+            prodDeploymentName?: string | null;
+            devDeploymentName?: string | null;
         };
         /** @description Summary of a project WorkOS environment for list responses - slimmer than
          *     full environment details, uses workos_ prefix for consistency with
          *     deployment */
         ProjectEnvironmentSummary: {
-            isProduction: boolean;
-            /** @description The user-provided environment name (e.g., "staging", "development") */
-            userEnvironmentName: string;
-            workosClientId: string;
             workosEnvironmentId: string;
             workosEnvironmentName: string;
+            workosClientId: string;
+            /** @description The user-provided environment name (e.g., "staging", "development") */
+            userEnvironmentName: string;
+            isProduction: boolean;
         };
         /** Format: int64 */
         ProjectId: number;
         ProjectName: string;
         ProjectSlug: string;
         ProvisionEnvironmentResponse: {
-            apiKey: string;
-            clientId: string;
             environmentId: string;
             environmentName: string;
+            clientId: string;
+            apiKey: string;
             newlyProvisioned: boolean;
         };
         ProvisionProjectEnvironmentRequest: {
@@ -439,25 +439,25 @@ export interface components {
         /** @description Response for provisioning a project WorkOS environment - matches
          *     ProvisionEnvironmentResponse pattern with workos_ prefix for consistency */
         ProvisionProjectEnvironmentResponse: {
+            workosEnvironmentId: string;
+            workosEnvironmentName: string;
+            workosClientId: string;
+            workosApiKey: string;
             newlyProvisioned: boolean;
             /** @description The user-provided environment name (e.g., "staging", "development") */
             userEnvironmentName: string;
-            workosApiKey: string;
-            workosClientId: string;
-            workosEnvironmentId: string;
-            workosEnvironmentName: string;
         };
         ProvisionWorkOSTeamRequest: {
+            /** @description Convex team ID, no WorkOS team exists at this point */
+            teamId: components["schemas"]["TeamId"];
             /** @description Email address to use for the WorkOS team admin,
              *     must be a verified email address associated with the user's account */
             email: string;
-            /** @description Convex team ID, no WorkOS team exists at this point */
-            teamId: components["schemas"]["TeamId"];
         };
         ProvisionWorkOSTeamResponse: {
-            adminEmail: string;
             workosTeamId: string;
             workosTeamName: string;
+            adminEmail: string;
         };
         ReferralCode: string;
         /** @enum {string} */
@@ -466,30 +466,30 @@ export interface components {
         TeamId: number;
         TeamName: string;
         TeamResponse: {
-            creator?: null | components["schemas"]["MemberId"];
-            defaultRegion?: null | components["schemas"]["RegionName"];
             id: components["schemas"]["TeamId"];
-            managedBy?: null | components["schemas"]["ManagedBy"];
-            managedByUrl?: string | null;
             name: components["schemas"]["TeamName"];
+            slug: components["schemas"]["TeamSlug"];
+            creator?: null | components["schemas"]["MemberId"];
+            suspended: boolean;
             referralCode: components["schemas"]["ReferralCode"];
             referredBy?: null | components["schemas"]["TeamId"];
-            slug: components["schemas"]["TeamSlug"];
+            managedBy?: null | components["schemas"]["ManagedBy"];
+            defaultRegion?: null | components["schemas"]["RegionName"];
             ssoLoginId?: string | null;
-            suspended: boolean;
+            managedByUrl?: string | null;
         };
         TeamSlug: string;
         WorkOSEnvironmentHealthResponse: {
-            clientId: string;
             id: string;
             name: string;
+            clientId: string;
         };
         /** @enum {string} */
         WorkOSProductionState: "active" | "inactive" | "suspended" | "deleting";
         WorkOSTeamHealthResponse: {
-            teamInfo?: null | components["schemas"]["WorkOSTeamInfo"];
             /** @description Whether a WorkOS team has been provisioned for this Convex team */
             teamProvisioned: boolean;
+            teamInfo?: null | components["schemas"]["WorkOSTeamInfo"];
         };
         WorkOSTeamInfo: {
             id: string;

package/src/cli/lib/deployApi/validator.ts

@@ -5,6 +5,7 @@ const baseConvexValidator = z.discriminatedUnion("type", [
   looseObject({ type: z.literal("null") }),
   looseObject({ type: z.literal("number") }),
   looseObject({ type: z.literal("bigint") }),
+  looseObject({ type: z.literal("commitTs") }),
   looseObject({ type: z.literal("boolean") }),
   looseObject({ type: z.literal("string") }),
   looseObject({ type: z.literal("bytes") }),

package/src/cli/lib/deploymentSelection.ts

@@ -1,4 +1,4 @@
-import { PlatformProjectDetails } from "@convex-dev/platform/managementApi";
+import { ProjectResponse } from "@convex-dev/platform/managementApi";
 import { BigBrainAuth, Context } from "../../bundler/context.js";
 import { logVerbose } from "../../bundler/log.js";
 import {
@@ -940,7 +940,7 @@ export const shouldAllowAnonymousDevelopment = (): boolean => {
 export async function getProjectDetails(
   ctx: Context,
   projectSelection: ProjectSelection,
-): Promise<PlatformProjectDetails> {
+): Promise<ProjectResponse> {
   switch (projectSelection.kind) {
     case "deploymentName": {
       if (projectSelection.deploymentType === "local") {

package/src/cli/lib/generateDocs.test.ts

@@ -170,7 +170,7 @@ describe("generateDocs", () => {
     const md = generateDocs(makeFakeRoot())["item.mdx"];
     expect(md).toContain("## `npx fake item add` \\{#add}");
     expect(md).toContain("## `npx fake item list` \\{#list}");
-    expect(md).toContain("### Usage");
+    expect(md).toContain("### Syntax");
   });
 
   it("documents aliases for nested subcommands inside the main command file", () => {

package/src/cli/lib/generateDocs.ts

@@ -102,9 +102,9 @@ function displayName(path: string[]): string {
   return `npx ${path.join(" ")}`;
 }
 
-// Build the usage suffix (everything after the command name) for the Usage
+// Build the usage suffix (everything after the command name) for the Syntax
 // code block. We derive the argument portion from the command's registered
-// arguments rather than trusting a manual `.usage()` override, so the Usage
+// arguments rather than trusting a manual `.usage()` override, so the Syntax
 // line always agrees with the Arguments section below. For example `env set`
 // overrides `.usage()` to show `<name> <value>` (pretending the args are
 // required) for nicer `--help` output, even though it registers them as
@@ -183,7 +183,7 @@ function renderCommand(
   }
 
   const usage = commandUsage(command);
-  lines.push(`${h2} Usage`);
+  lines.push(`${h2} Syntax`);
   lines.push("");
   lines.push("```sh");
   lines.push(`${display} ${usage}`.trim());

package/src/cli/lib/generatedFunctionLogsApi.ts

@@ -8,72 +8,72 @@ export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
         FunctionExecutionJson: {
+            udfType: components["schemas"]["UdfTypeJson"];
+            componentPath?: string | null;
+            identifier: string;
+            logLines: components["schemas"]["Value"][];
+            /** Format: double */
+            timestamp: number;
             cachedResult: boolean;
             caller: string;
-            componentPath?: string | null;
-            environment: string;
+            parentExecutionId?: string | null;
+            /** Format: double */
+            executionTime: number;
+            /** Format: double */
+            userExecutionTime?: number | null;
+            success?: null | components["schemas"]["Value"];
             error?: string | null;
+            requestId: string;
             executionId: string;
+            usageStats: components["schemas"]["UsageStatsJson"];
             /** Format: double */
-            executionTime: number;
+            returnBytes?: number | null;
+            occInfo?: null | components["schemas"]["OccInfoJson"];
+            willRetry: boolean;
             /** Format: double */
             executionTimestamp: number;
-            identifier: string;
             identityType: string;
+            environment: string;
             /** @enum {string} */
             kind: "Completion";
-            logLines: components["schemas"]["Value"][];
-            occInfo?: null | components["schemas"]["OccInfoJson"];
-            parentExecutionId?: string | null;
-            requestId: string;
-            /** Format: double */
-            returnBytes?: number | null;
-            success?: null | components["schemas"]["Value"];
-            /** Format: double */
-            timestamp: number;
-            udfType: components["schemas"]["UdfTypeJson"];
-            usageStats: components["schemas"]["UsageStatsJson"];
-            /** Format: double */
-            userExecutionTime?: number | null;
-            willRetry: boolean;
         } | {
+            udfType: components["schemas"]["UdfTypeJson"];
             componentPath?: string | null;
-            executionId: string;
             identifier: string;
-            /** @enum {string} */
-            kind: "Progress";
-            logLines: components["schemas"]["Value"][];
-            requestId: string;
             /** Format: double */
             timestamp: number;
-            udfType: components["schemas"]["UdfTypeJson"];
+            logLines: components["schemas"]["Value"][];
+            requestId: string;
+            executionId: string;
+            /** @enum {string} */
+            kind: "Progress";
         };
         /** @enum {string} */
         LogLevelJson: "DEBUG" | "ERROR" | "WARN" | "INFO" | "LOG";
         LogLineJson: {
-            componentPath?: string | null;
-            isTruncated: boolean;
-            level: components["schemas"]["LogLevelJson"];
             messages: string[];
-            systemMetadata?: null | components["schemas"]["SystemLogMetadataJson"];
+            isTruncated: boolean;
             /** Format: int64 */
             timestamp: number;
+            level: components["schemas"]["LogLevelJson"];
+            systemMetadata?: null | components["schemas"]["SystemLogMetadataJson"];
+            componentPath?: string | null;
             udfPath?: string | null;
         };
         OccInfoJson: {
-            componentPath?: string | null;
+            tableName?: string | null;
             documentId?: string | null;
+            writeSource?: string | null;
+            componentPath?: string | null;
             /** Format: int64 */
             retryCount?: number | null;
-            tableName?: string | null;
-            writeSource?: string | null;
         };
         StreamFunctionLogs: {
-            /** Format: int32 */
-            clientRequestCounter?: number | null;
             /** Format: double */
             cursor: number;
             sessionId?: string | null;
+            /** Format: int32 */
+            clientRequestCounter?: number | null;
         };
         StreamUdfExecutionQueryArgs: {
             /** Format: double */
@@ -90,36 +90,36 @@ export interface components {
         /** @enum {string} */
         UdfTypeJson: "Query" | "Mutation" | "Action" | "HttpAction";
         UsageStatsJson: {
-            /** Format: int64 */
-            databaseIoReadBytes: number;
-            /** Format: int64 */
-            databaseIoWriteBytes: number;
             /** Format: int64 */
             databaseReadBytes: number;
             /** Format: int64 */
-            databaseReadDocuments: number;
-            /** Format: int64 */
             databaseWriteBytes: number;
             /** Format: int64 */
-            memoryUsedMb: number;
+            databaseIoReadBytes: number;
             /** Format: int64 */
-            networkEgressBytes: number;
+            databaseIoWriteBytes: number;
+            /** Format: int64 */
+            databaseReadDocuments: number;
             /** Format: int64 */
             storageReadBytes: number;
             /** Format: int64 */
             storageWriteBytes: number;
             /** Format: int64 */
+            vectorIndexReadBytes: number;
+            /** Format: int64 */
+            vectorIndexWriteBytes: number;
+            /** Format: int64 */
             textIndexQueryBytes: number;
             /** Format: int64 */
             textIndexWriteQueryBytes: number;
             /** Format: int64 */
-            vectorIndexReadBytes: number;
-            /** Format: int64 */
             vectorIndexReadQueryBytes: number;
             /** Format: int64 */
-            vectorIndexWriteBytes: number;
-            /** Format: int64 */
             vectorIndexWriteQueryBytes: number;
+            /** Format: int64 */
+            networkEgressBytes: number;
+            /** Format: int64 */
+            memoryUsedMb: number;
         };
         Value: unknown;
     };

package/src/cli/lib/localDeployment/projectMismatch.ts

@@ -1,4 +1,4 @@
-import { PlatformProjectDetails } from "@convex-dev/platform/managementApi";
+import { ProjectResponse } from "@convex-dev/platform/managementApi";
 import { Context } from "../../../bundler/context.js";
 import { logVerbose } from "../../../bundler/log.js";
 import {
@@ -19,7 +19,7 @@ export async function targetProjectForLocalSelector(
   ctx: Context,
   parsed: ParsedDeploymentSelector,
   currentSelection: DeploymentSelection,
-): Promise<PlatformProjectDetails | null> {
+): Promise<ProjectResponse | null> {
   switch (parsed.kind) {
     case "inTeamProject":
       return await getProjectDetails(ctx, {

package/src/cli/lib/login.ts

@@ -326,46 +326,44 @@ export async function performLogin(
   }
 
   const issuer = overrideAuthUrl ?? "https://auth.convex.dev";
-  let authIssuer;
+  const clientId = overrideAuthClient ?? "HFtA247jp9iNs08NTLIB7JsNPMmRIyfi";
   let accessToken: string;
 
-  if (loginFlow === "paste" || (loginFlow === "auto" && isWebContainer())) {
+  if (overrideAccessToken) {
+    // Access token was supplied directly.
+    accessToken = overrideAccessToken;
+  } else if (overrideAuthUsername && overrideAuthPassword) {
+    // Username/Password auth
+    accessToken = await performPasswordAuthentication(
+      ctx,
+      clientId,
+      overrideAuthUsername,
+      overrideAuthPassword,
+    );
+  } else if (
+    loginFlow === "paste" ||
+    (loginFlow === "auto" && isWebContainer())
+  ) {
     accessToken = await promptString(ctx, {
       message:
         "Open https://dashboard.convex.dev/auth, log in and paste the token here:",
     });
   } else {
+    // Device authorization flow. Contact OIDC issuer.
+    let authIssuer;
     try {
       authIssuer = await Issuer.discover(issuer);
     } catch {
       // Couldn't contact https://auth.convex.dev/.well-known/openid-configuration,
       // proceed with manual auth.
-      accessToken = await promptString(ctx, {
-        message:
-          "Open https://dashboard.convex.dev/auth, log in and paste the token here:",
-      });
+      authIssuer = undefined;
     }
-  }
-
-  // typical path
-  if (authIssuer) {
-    const clientId = overrideAuthClient ?? "HFtA247jp9iNs08NTLIB7JsNPMmRIyfi";
-    const authClient = new authIssuer.Client({
-      client_id: clientId,
-      token_endpoint_auth_method: "none",
-      id_token_signed_response_alg: "RS256",
-    });
-
-    if (overrideAccessToken) {
-      accessToken = overrideAccessToken;
-    } else if (overrideAuthUsername && overrideAuthPassword) {
-      accessToken = await performPasswordAuthentication(
-        ctx,
-        clientId,
-        overrideAuthUsername,
-        overrideAuthPassword,
-      );
-    } else {
+    if (authIssuer) {
+      const authClient = new authIssuer.Client({
+        client_id: clientId,
+        token_endpoint_auth_method: "none",
+        id_token_signed_response_alg: "RS256",
+      });
       accessToken = await performDeviceAuthorization(
         ctx,
         authClient,
@@ -373,11 +371,16 @@ export async function performLogin(
         vercel,
         vercelOverride,
       );
+    } else {
+      accessToken = await promptString(ctx, {
+        message:
+          "Open https://dashboard.convex.dev/auth, log in and paste the token here:",
+      });
     }
   }
 
   if (dumpAccessToken) {
-    logOutput(`${accessToken!}`);
+    logOutput(`${accessToken}`);
     return await ctx.crash({
       exitCode: 0,
       errorType: "fatal",
@@ -387,9 +390,9 @@ export async function performLogin(
 
   // Exchange the WorkOS access token for a Convex personal access token.
   ctx._updateBigBrainAuth({
-    accessToken: accessToken!,
+    accessToken: accessToken,
     kind: "accessToken",
-    header: `Bearer ${accessToken!}`,
+    header: `Bearer ${accessToken}`,
   });
   const response = await typedPlatformClient(ctx).POST(
     "/create_personal_access_token",

package/src/cli/lib/typecheck.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "vitest";
+import path from "path";
+import { findTypeScriptCompilerPath } from "./typecheck.js";
+import type { TypescriptCompiler } from "./typecheck.js";
+
+const compilerPaths = {
+  tsc: path.join("node_modules", "typescript", "bin", "tsc"),
+  native: path.join("node_modules", "@typescript", "native", "bin", "tsc"),
+  tsgo: path.join(
+    "node_modules",
+    "@typescript",
+    "native-preview",
+    "bin",
+    "tsgo",
+  ),
+  legacyTsgo: path.join(
+    "node_modules",
+    "@typescript",
+    "native-preview",
+    "bin",
+    "tsgo.js",
+  ),
+} as const;
+
+describe("findTypeScriptCompilerPath", () => {
+  test.each<{
+    compiler: TypescriptCompiler;
+    existing: string[];
+    expected: string | undefined;
+  }>([
+    {
+      compiler: "tsc",
+      existing: [compilerPaths.tsc],
+      expected: compilerPaths.tsc,
+    },
+    {
+      compiler: "tsc",
+      existing: [compilerPaths.native],
+      expected: compilerPaths.native,
+    },
+    {
+      compiler: "tsc",
+      existing: [compilerPaths.tsc, compilerPaths.native],
+      expected: compilerPaths.native,
+    },
+    {
+      compiler: "tsgo",
+      existing: [compilerPaths.tsgo],
+      expected: compilerPaths.tsgo,
+    },
+    {
+      compiler: "tsgo",
+      existing: [compilerPaths.legacyTsgo],
+      expected: compilerPaths.legacyTsgo,
+    },
+    {
+      compiler: "tsgo",
+      existing: [compilerPaths.tsgo, compilerPaths.legacyTsgo],
+      expected: compilerPaths.tsgo,
+    },
+    { compiler: "tsc", existing: [], expected: undefined },
+    { compiler: "tsgo", existing: [], expected: undefined },
+  ])("finds $expected for $compiler", ({ compiler, existing, expected }) => {
+    expect(
+      findTypeScriptCompilerPath(
+        { exists: (candidate) => existing.includes(candidate) },
+        compiler,
+      ),
+    ).toBe(expected);
+  });
+});