alepha 0.22.0 → 0.24.0

package/src/cli/platform-lib/schemas/cloudflare.ts

@@ -1,13 +1,13 @@
 import type { Static } from "alepha";
-import { t } from "alepha";
+import { z } from "alepha";
 
 // ---------------------------------------------------------------------------
 // Account
 // ---------------------------------------------------------------------------
 
-export const cloudflareAccountSchema = t.object({
-  id: t.string(),
-  name: t.string(),
+export const cloudflareAccountSchema = z.object({
+  id: z.string(),
+  name: z.string(),
 });
 
 export type CloudflareAccount = Static<typeof cloudflareAccountSchema>;
@@ -16,9 +16,9 @@ export type CloudflareAccount = Static<typeof cloudflareAccountSchema>;
 // D1
 // ---------------------------------------------------------------------------
 
-export const cloudflareD1Schema = t.object({
-  uuid: t.string(),
-  name: t.string(),
+export const cloudflareD1Schema = z.object({
+  uuid: z.string(),
+  name: z.string(),
 });
 
 export type CloudflareD1 = Static<typeof cloudflareD1Schema>;
@@ -27,9 +27,9 @@ export type CloudflareD1 = Static<typeof cloudflareD1Schema>;
 // KV
 // ---------------------------------------------------------------------------
 
-export const cloudflareKVSchema = t.object({
-  id: t.string(),
-  title: t.string(),
+export const cloudflareKVSchema = z.object({
+  id: z.string(),
+  title: z.string(),
 });
 
 export type CloudflareKV = Static<typeof cloudflareKVSchema>;
@@ -38,32 +38,32 @@ export type CloudflareKV = Static<typeof cloudflareKVSchema>;
 // R2
 // ---------------------------------------------------------------------------
 
-export const cloudflareR2Schema = t.object({
-  name: t.string(),
-  creation_date: t.optional(t.string()),
+export const cloudflareR2Schema = z.object({
+  name: z.string(),
+  creation_date: z.string().optional(),
 });
 
 export type CloudflareR2 = Static<typeof cloudflareR2Schema>;
 
-export const cloudflareR2ListSchema = t.object({
-  buckets: t.array(cloudflareR2Schema),
+export const cloudflareR2ListSchema = z.object({
+  buckets: z.array(cloudflareR2Schema),
 });
 
 // ---------------------------------------------------------------------------
 // Queue
 // ---------------------------------------------------------------------------
 
-export const cloudflareQueueSchema = t.object({
-  queue_id: t.string(),
-  queue_name: t.string(),
+export const cloudflareQueueSchema = z.object({
+  queue_id: z.string(),
+  queue_name: z.string(),
 });
 
 export type CloudflareQueue = Static<typeof cloudflareQueueSchema>;
 
-export const cloudflareQueueConsumerSchema = t.object({
-  consumer_id: t.string(),
-  service: t.string(),
-  environment: t.optional(t.string()),
+export const cloudflareQueueConsumerSchema = z.object({
+  consumer_id: z.string(),
+  service: z.string(),
+  environment: z.string().optional(),
 });
 
 export type CloudflareQueueConsumer = Static<
@@ -74,13 +74,13 @@ export type CloudflareQueueConsumer = Static<
 // Hyperdrive
 // ---------------------------------------------------------------------------
 
-export const cloudflareHyperdriveOriginSchema = t.object({
-  host: t.string(),
+export const cloudflareHyperdriveOriginSchema = z.object({
+  host: z.string(),
 });
 
-export const cloudflareHyperdriveSchema = t.object({
-  id: t.string(),
-  name: t.string(),
+export const cloudflareHyperdriveSchema = z.object({
+  id: z.string(),
+  name: z.string(),
   origin: cloudflareHyperdriveOriginSchema,
 });
 
@@ -90,10 +90,10 @@ export type CloudflareHyperdrive = Static<typeof cloudflareHyperdriveSchema>;
 // Worker
 // ---------------------------------------------------------------------------
 
-export const cloudflareWorkerSchema = t.object({
-  id: t.string(),
-  created_on: t.string(),
-  modified_on: t.string(),
+export const cloudflareWorkerSchema = z.object({
+  id: z.string(),
+  created_on: z.string(),
+  modified_on: z.string(),
 });
 
 export type CloudflareWorker = Static<typeof cloudflareWorkerSchema>;
@@ -102,48 +102,48 @@ export type CloudflareWorker = Static<typeof cloudflareWorkerSchema>;
 // Deployment
 // ---------------------------------------------------------------------------
 
-export const cloudflareDeploymentVersionSchema = t.object({
-  version_id: t.string(),
-  percentage: t.number(),
+export const cloudflareDeploymentVersionSchema = z.object({
+  version_id: z.string(),
+  percentage: z.number(),
 });
 
-export const cloudflareDeploymentSchema = t.object({
-  id: t.string(),
-  versions: t.array(cloudflareDeploymentVersionSchema),
-  created_on: t.string(),
+export const cloudflareDeploymentSchema = z.object({
+  id: z.string(),
+  versions: z.array(cloudflareDeploymentVersionSchema),
+  created_on: z.string(),
 });
 
 export type CloudflareDeployment = Static<typeof cloudflareDeploymentSchema>;
 
-export const cloudflareDeploymentListSchema = t.object({
-  deployments: t.array(cloudflareDeploymentSchema),
+export const cloudflareDeploymentListSchema = z.object({
+  deployments: z.array(cloudflareDeploymentSchema),
 });
 
 // ---------------------------------------------------------------------------
 // Version
 // ---------------------------------------------------------------------------
 
-export const cloudflareVersionSchema = t.object({
-  id: t.string(),
-  metadata: t.object({
-    created_on: t.string(),
+export const cloudflareVersionSchema = z.object({
+  id: z.string(),
+  metadata: z.object({
+    created_on: z.string(),
   }),
-  annotations: t.optional(t.record(t.string(), t.string())),
+  annotations: z.record(z.string(), z.string()).optional(),
 });
 
 export type CloudflareVersion = Static<typeof cloudflareVersionSchema>;
 
-export const cloudflareVersionListSchema = t.object({
-  items: t.array(cloudflareVersionSchema),
+export const cloudflareVersionListSchema = z.object({
+  items: z.array(cloudflareVersionSchema),
 });
 
 // ---------------------------------------------------------------------------
 // Secret
 // ---------------------------------------------------------------------------
 
-export const cloudflareSecretSchema = t.object({
-  name: t.string(),
-  type: t.string(),
+export const cloudflareSecretSchema = z.object({
+  name: z.string(),
+  type: z.string(),
 });
 
 export type CloudflareSecret = Static<typeof cloudflareSecretSchema>;
@@ -152,18 +152,18 @@ export type CloudflareSecret = Static<typeof cloudflareSecretSchema>;
 // Request bodies
 // ---------------------------------------------------------------------------
 
-export const createD1BodySchema = t.object({
-  name: t.string(),
-  primary_location_hint: t.optional(t.string()),
-  jurisdiction: t.optional(t.string()),
+export const createD1BodySchema = z.object({
+  name: z.string(),
+  primary_location_hint: z.string().optional(),
+  jurisdiction: z.string().optional(),
 });
 
-export const createKVBodySchema = t.object({
-  title: t.string(),
+export const createKVBodySchema = z.object({
+  title: z.string(),
 });
 
-export const createR2BodySchema = t.object({
-  name: t.string(),
+export const createR2BodySchema = z.object({
+  name: z.string(),
 });
 
 // ---------------------------------------------------------------------------
@@ -171,56 +171,56 @@ export const createR2BodySchema = t.object({
 // minted from a wrangler bearer token, revoked immediately after use)
 // ---------------------------------------------------------------------------
 
-export const cloudflareR2TokenSchema = t.object({
-  id: t.string(),
-  accessKeyId: t.string(),
-  secretAccessKey: t.string(),
+export const cloudflareR2TokenSchema = z.object({
+  id: z.string(),
+  accessKeyId: z.string(),
+  secretAccessKey: z.string(),
 });
 
 export type CloudflareR2Token = Static<typeof cloudflareR2TokenSchema>;
 
-export const createR2TokenBodySchema = t.object({
-  name: t.string(),
-  policies: t.array(
-    t.object({
-      effect: t.string(),
-      permissions: t.array(t.string()),
-      buckets: t.optional(t.array(t.string())),
+export const createR2TokenBodySchema = z.object({
+  name: z.string(),
+  policies: z.array(
+    z.object({
+      effect: z.string(),
+      permissions: z.array(z.string()),
+      buckets: z.array(z.string()).optional(),
     }),
   ),
 });
 
-export const createQueueBodySchema = t.object({
-  queue_name: t.string(),
+export const createQueueBodySchema = z.object({
+  queue_name: z.string(),
 });
 
-export const createHyperdriveOriginSchema = t.object({
-  scheme: t.string(),
-  host: t.string(),
-  port: t.number(),
-  database: t.string(),
-  user: t.string(),
-  password: t.string(),
+export const createHyperdriveOriginSchema = z.object({
+  scheme: z.string(),
+  host: z.string(),
+  port: z.number(),
+  database: z.string(),
+  user: z.string(),
+  password: z.string(),
 });
 
-export const createHyperdriveBodySchema = t.object({
-  name: t.string(),
+export const createHyperdriveBodySchema = z.object({
+  name: z.string(),
   origin: createHyperdriveOriginSchema,
 });
 
-export const putSecretBodySchema = t.object({
-  name: t.string(),
-  text: t.string(),
-  type: t.string(),
+export const putSecretBodySchema = z.object({
+  name: z.string(),
+  text: z.string(),
+  type: z.string(),
 });
 
 // ---------------------------------------------------------------------------
 // API envelope
 // ---------------------------------------------------------------------------
 
-export const cloudflareApiErrorSchema = t.object({
-  code: t.number(),
-  message: t.string(),
+export const cloudflareApiErrorSchema = z.object({
+  code: z.number(),
+  message: z.string(),
 });
 
 export type CloudflareApiError = Static<typeof cloudflareApiErrorSchema>;

package/src/cli/platform-lib/schemas/platform.ts

@@ -1,42 +1,42 @@
 import type { Static } from "alepha";
-import { t } from "alepha";
+import { z } from "alepha";
 
 // ---------------------------------------------------------------------------
 // Status output
 // ---------------------------------------------------------------------------
 
-export const platformStatusWorkerSchema = t.object({
-  name: t.string(),
-  exists: t.boolean(),
-  id: t.optional(t.string()),
-  detail: t.optional(t.string()),
-  version: t.optional(t.string()),
-  tag: t.optional(t.string()),
-  createdAt: t.optional(t.string()),
+export const platformStatusWorkerSchema = z.object({
+  name: z.string(),
+  exists: z.boolean(),
+  id: z.string().optional(),
+  detail: z.string().optional(),
+  version: z.string().optional(),
+  tag: z.string().optional(),
+  createdAt: z.string().optional(),
 });
 
-export const platformStatusResourceSchema = t.object({
-  name: t.string(),
-  exists: t.boolean(),
-  id: t.optional(t.string()),
-  detail: t.optional(t.string()),
+export const platformStatusResourceSchema = z.object({
+  name: z.string(),
+  exists: z.boolean(),
+  id: z.string().optional(),
+  detail: z.string().optional(),
 });
 
-export const platformStatusSecretSchema = t.object({
-  name: t.string(),
-  deployed: t.boolean(),
+export const platformStatusSecretSchema = z.object({
+  name: z.string(),
+  deployed: z.boolean(),
 });
 
-export const platformStatusSchema = t.object({
-  project: t.string(),
-  env: t.string(),
-  adapter: t.string(),
-  workers: t.array(platformStatusWorkerSchema),
-  databases: t.array(platformStatusResourceSchema),
-  buckets: t.array(platformStatusResourceSchema),
-  kvNamespaces: t.array(platformStatusResourceSchema),
-  queues: t.array(platformStatusResourceSchema),
-  secrets: t.array(platformStatusSecretSchema),
+export const platformStatusSchema = z.object({
+  project: z.string(),
+  env: z.string(),
+  adapter: z.string(),
+  workers: z.array(platformStatusWorkerSchema),
+  databases: z.array(platformStatusResourceSchema),
+  buckets: z.array(platformStatusResourceSchema),
+  kvNamespaces: z.array(platformStatusResourceSchema),
+  queues: z.array(platformStatusResourceSchema),
+  secrets: z.array(platformStatusSecretSchema),
 });
 
 export type PlatformStatusOutput = Static<typeof platformStatusSchema>;
@@ -45,39 +45,39 @@ export type PlatformStatusOutput = Static<typeof platformStatusSchema>;
 // Plan output
 // ---------------------------------------------------------------------------
 
-export const platformPlanAppResourcesSchema = t.object({
-  hasDatabase: t.boolean(),
-  hasBucket: t.boolean(),
-  hasKV: t.boolean(),
-  hasQueue: t.boolean(),
-  hasCron: t.boolean(),
+export const platformPlanAppResourcesSchema = z.object({
+  hasDatabase: z.boolean(),
+  hasBucket: z.boolean(),
+  hasKV: z.boolean(),
+  hasQueue: z.boolean(),
+  hasCron: z.boolean(),
 });
 
-export const platformPlanAppSchema = t.object({
-  name: t.string(),
-  path: t.string(),
+export const platformPlanAppSchema = z.object({
+  name: z.string(),
+  path: z.string(),
   resources: platformPlanAppResourcesSchema,
 });
 
-export const platformPlanEnvironmentSchema = t.object({
-  adapter: t.string(),
-  domain: t.optional(t.string()),
-  zone: t.optional(t.string()),
+export const platformPlanEnvironmentSchema = z.object({
+  adapter: z.string(),
+  domain: z.string().optional(),
+  zone: z.string().optional(),
 });
 
-export const platformPlanResourceSchema = t.object({
-  label: t.string(),
-  value: t.string(),
+export const platformPlanResourceSchema = z.object({
+  label: z.string(),
+  value: z.string(),
 });
 
-export const platformPlanSchema = t.object({
-  project: t.string(),
-  env: t.string(),
-  mode: t.enum(["monorepo", "standalone"]),
-  apps: t.array(platformPlanAppSchema),
-  environments: t.record(t.string(), platformPlanEnvironmentSchema),
-  resources: t.array(platformPlanResourceSchema),
-  secretCount: t.number(),
+export const platformPlanSchema = z.object({
+  project: z.string(),
+  env: z.string(),
+  mode: z.enum(["monorepo", "standalone"]),
+  apps: z.array(platformPlanAppSchema),
+  environments: z.record(z.string(), platformPlanEnvironmentSchema),
+  resources: z.array(platformPlanResourceSchema),
+  secretCount: z.number(),
 });
 
 export type PlatformPlanOutput = Static<typeof platformPlanSchema>;

package/src/cli/platform-lib/schemas/vercel.ts

@@ -1,36 +1,36 @@
 import type { Static } from "alepha";
-import { t } from "alepha";
+import { z } from "alepha";
 
 // ---------------------------------------------------------------------------
 // Project
 // ---------------------------------------------------------------------------
 
-export const vercelProjectSchema = t.object({
-  id: t.string(),
-  name: t.string(),
-  accountId: t.string(),
+export const vercelProjectSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  accountId: z.string(),
 });
 
 export type VercelProject = Static<typeof vercelProjectSchema>;
 
-export const createProjectBodySchema = t.object({
-  name: t.string(),
-  framework: t.optional(t.null()),
+export const createProjectBodySchema = z.object({
+  name: z.string(),
+  framework: z.null().optional(),
 });
 
 // ---------------------------------------------------------------------------
 // Deployment
 // ---------------------------------------------------------------------------
 
-export const vercelDeploymentSchema = t.object({
-  uid: t.string(),
-  name: t.string(),
-  url: t.string(),
-  state: t.optional(t.string()),
-  readyState: t.optional(t.string()),
-  created: t.optional(t.number()),
-  target: t.optional(t.string()),
-  alias: t.optional(t.array(t.string())),
+export const vercelDeploymentSchema = z.object({
+  uid: z.string(),
+  name: z.string(),
+  url: z.string(),
+  state: z.string().optional(),
+  readyState: z.string().optional(),
+  created: z.number().optional(),
+  target: z.string().optional(),
+  alias: z.array(z.string()).optional(),
 });
 
 export type VercelDeployment = Static<typeof vercelDeploymentSchema>;
@@ -39,19 +39,19 @@ export type VercelDeployment = Static<typeof vercelDeploymentSchema>;
 // Environment Variable
 // ---------------------------------------------------------------------------
 
-export const vercelEnvVarSchema = t.object({
-  id: t.string(),
-  key: t.string(),
-  value: t.optional(t.string()),
-  type: t.string(),
-  target: t.array(t.string()),
+export const vercelEnvVarSchema = z.object({
+  id: z.string(),
+  key: z.string(),
+  value: z.string().optional(),
+  type: z.string(),
+  target: z.array(z.string()),
 });
 
 export type VercelEnvVar = Static<typeof vercelEnvVarSchema>;
 
-export const createEnvVarBodySchema = t.object({
-  key: t.string(),
-  value: t.string(),
-  type: t.string(),
-  target: t.array(t.string()),
+export const createEnvVarBodySchema = z.object({
+  key: z.string(),
+  value: z.string(),
+  type: z.string(),
+  target: z.array(z.string()),
 });

package/src/cli/platform-lib/services/CloudflareApi.ts

@@ -1,4 +1,4 @@
-import { $inject, Alepha, AlephaError, type TSchema, t } from "alepha";
+import { $inject, Alepha, AlephaError, type TSchema, z } from "alepha";
 import { $logger } from "alepha/logger";
 import type {
   CloudflareAccount,
@@ -128,7 +128,7 @@ export class CloudflareApi {
     }
 
     const res = await this.fetch<CloudflareAccount[]>("/accounts", {
-      schema: t.array(cloudflareAccountSchema),
+      schema: z.array(cloudflareAccountSchema),
     });
 
     if (res.length === 0) {
@@ -443,7 +443,7 @@ export class CloudflareApi {
     const accountId = await this.resolveAccountId();
     return await this.fetch<CloudflareSecret[]>(
       `/accounts/${accountId}/workers/scripts/${scriptName}/secrets`,
-      { schema: t.array(cloudflareSecretSchema) },
+      { schema: z.array(cloudflareSecretSchema) },
     );
   }
 
@@ -635,7 +635,7 @@ export class CloudflareApi {
       }
 
       const validated = this.alepha.codec.validate(
-        t.array(itemSchema),
+        z.array(itemSchema),
         json.result,
       ) as T[];
       results.push(...validated);
@@ -673,7 +673,7 @@ export class CloudflareApi {
       const res = await this.fetch<Record<string, unknown>>(path, { query });
       const items = (res[itemsKey] as unknown[]) ?? [];
       const validated = this.alepha.codec.validate(
-        t.array(itemSchema),
+        z.array(itemSchema),
         items,
       ) as T[];
       results.push(...validated);

package/src/cli/platform-lib/services/VercelApi.ts

@@ -1,4 +1,4 @@
-import { $inject, Alepha, AlephaError, type TSchema, t } from "alepha";
+import { $inject, Alepha, AlephaError, type TSchema, z } from "alepha";
 import { $logger } from "alepha/logger";
 import type {
   VercelDeployment,
@@ -51,7 +51,7 @@ export class VercelApi {
   public async listProjects(): Promise<VercelProject[]> {
     const res = await this.fetch<{ projects: VercelProject[] }>(
       "/v10/projects",
-      { schema: t.object({ projects: t.array(vercelProjectSchema) }) },
+      { schema: z.object({ projects: z.array(vercelProjectSchema) }) },
     );
     return res.projects;
   }
@@ -114,7 +114,7 @@ export class VercelApi {
       "/v6/deployments",
       {
         query,
-        schema: t.object({ deployments: t.array(vercelDeploymentSchema) }),
+        schema: z.object({ deployments: z.array(vercelDeploymentSchema) }),
       },
     );
     return res.deployments;
@@ -129,7 +129,7 @@ export class VercelApi {
       `/v10/projects/${encodeURIComponent(projectId)}/env`,
       {
         query: { decrypt: "true" },
-        schema: t.object({ envs: t.array(vercelEnvVarSchema) }),
+        schema: z.object({ envs: z.array(vercelEnvVarSchema) }),
       },
     );
     return res.envs;

package/src/cli/platform-lib/services/VercelCli.ts

@@ -2,7 +2,6 @@ import { homedir, platform } from "node:os";
 import { join } from "node:path";
 import { $inject, AlephaError } from "alepha";
 import { AlephaCliUtils, PackageManagerUtils } from "alepha/cli";
-import { Runner, type RunnerMethod } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { FileSystemProvider, ShellProvider } from "alepha/system";
 
@@ -18,19 +17,16 @@ export class VercelCli {
   protected readonly fs = $inject(FileSystemProvider);
   protected readonly utils = $inject(AlephaCliUtils);
   protected readonly pm = $inject(PackageManagerUtils);
-  protected readonly runner = $inject(Runner);
 
   protected async runShell(
     command: string,
     options: Parameters<ShellProvider["run"]>[1] = {},
   ) {
-    const capture = options.capture;
-    const output = await this.shell.run(command, {
-      ...options,
-      capture: capture ?? this.runner.useDynamicLogger,
-    });
+    const output = await this.shell.run(command, options);
 
-    if (capture && !this.runner.useDynamicLogger) {
+    // When the caller captured the output, echo it to the log so the user
+    // still sees it (uncaptured commands stream straight to the terminal).
+    if (options.capture) {
       this.log.info(output);
     }
 
@@ -44,16 +40,11 @@ export class VercelCli {
   /**
    * Ensure vercel CLI is installed in the project.
    */
-  public async ensureInstalled(root: string, run: RunnerMethod): Promise<void> {
+  public async ensureInstalled(root: string): Promise<void> {
     await this.pm.ensureDependency(root, "vercel", {
       dev: true,
       exec: async (cmd, opts) => {
-        run.pause();
-        try {
-          await this.utils.exec(cmd, opts);
-        } finally {
-          run.resume();
-        }
+        await this.utils.exec(cmd, opts);
       },
     });
   }