alchemy 0.70.0 → 0.70.2

package/src/clickhouse/service.ts

@@ -5,6 +5,26 @@ import { diff } from "../util/diff.ts";
 import { createClickhouseApi } from "./api.ts";
 import type { ClickhouseClient } from "./api/sdk.gen.ts";
 import type { Service as ApiService, Organization } from "./api/types.gen.ts";
+import { OrganizationRef } from "./organization.ts";
+
+type MysqlEndpoint = {
+  protocol: "mysql";
+  host: string;
+  port: number;
+  username: string;
+};
+
+type HttpsEndpoint = {
+  protocol: "https";
+  host: string;
+  port: number;
+};
+
+type NativesecureEndpoint = {
+  protocol: "nativesecure";
+  host: string;
+  port: number;
+};
 
 export interface ServiceProps {
   /**
@@ -18,7 +38,7 @@ export interface ServiceProps {
   secret?: string | Secret<string>;
 
   /**
-   * The id of Clickhouse cloud organization to create the service in.
+   * The id, name, or OrganizationRef of Clickhouse cloud organization to create the service in.
    */
   organization: string | Organization;
 
@@ -128,6 +148,13 @@ export interface ServiceProps {
    */
   complianceType?: ApiService["complianceType"];
 
+  /**
+   * wait for http service to be ready before marking the resource as created
+   *
+   * @default true
+   */
+  waitForHttpEndpointReady?: boolean;
+
   //todo(michael): I need to understand more about what these properties do before documenting
   //todo(michael): support linking to BYOC infrastructure directly
   byocId?: ApiService["byocId"];
@@ -269,30 +296,17 @@ export interface Service {
   /**
    * The mysql endpoint details of the Clickhouse service.
    */
-  mysqlEndpoint?: {
-    protocol: "mysql";
-    host: string;
-    port: number;
-    username: string;
-  };
+  mysqlEndpoint?: MysqlEndpoint;
 
   /**
    * The https endpoint details of the Clickhouse service.
    */
-  httpsEndpoint?: {
-    protocol: "https";
-    host: string;
-    port: number;
-  };
+  httpsEndpoint?: HttpsEndpoint;
 
   /**
    * The nativesecure endpoint details of the Clickhouse service.
    */
-  nativesecureEndpoint?: {
-    protocol: "nativesecure";
-    host: string;
-    port: number;
-  };
+  nativesecureEndpoint?: NativesecureEndpoint;
 
   /**
    * The desired state of the Clickhouse service.
@@ -310,7 +324,7 @@ export interface Service {
  *
  * @example
  * // Create a basic Clickhouse service on aws
- * const organization = await getOrganizationByName("Alchemy's Organization");
+ * const organization = await OrganizationRef("Alchemy's Organization");
  * const service = await Service("clickhouse", {
  *   organization,
  *   provider: "aws",
@@ -348,6 +362,7 @@ export const Service = Resource(
     if (enableMysqlEndpoint) {
       endpoints.push({ protocol: "mysql", enabled: true });
     }
+    const waitForHttpEndpointReady = props.waitForHttpEndpointReady ?? true;
     //todo(michael): comment these in when disabling is supported
     // const enableHttpsEndpoint = props.enableHttpsEndpoint ?? true;
     // if (enableHttpsEndpoint) {
@@ -374,7 +389,9 @@ export const Service = Resource(
 
     const organizationId =
       typeof props.organization === "string"
-        ? props.organization
+        ? await OrganizationRef(props.organization)
+            .then((organization) => organization.id!)
+            .catch(() => props.organization as string)
         : props.organization.id!;
 
     if (this.phase === "delete") {
@@ -393,7 +410,6 @@ export const Service = Resource(
         organizationId,
         this.output.clickhouseId,
         (state) => state === "stopped",
-        10 * 60,
       );
 
       await api.deleteService({
@@ -403,6 +419,12 @@ export const Service = Resource(
         },
       });
 
+      await waitForServiceDeletion(
+        api,
+        organizationId,
+        this.output.clickhouseId,
+      );
+
       return this.destroy();
     }
     if (this.phase === "update") {
@@ -481,13 +503,13 @@ export const Service = Resource(
         updates.releaseChannel = response.releaseChannel!;
         updates.mysqlEndpoint = response!.endpoints!.find(
           (endpoint) => endpoint.protocol === "mysql",
-        ) as any;
+        ) as MysqlEndpoint;
         updates.httpsEndpoint = response!.endpoints!.find(
           (endpoint) => endpoint.protocol === "https",
-        ) as any;
+        ) as HttpsEndpoint;
         updates.nativesecureEndpoint = response!.endpoints!.find(
           (endpoint) => endpoint.protocol === "nativesecure",
-        ) as any;
+        ) as NativesecureEndpoint;
       }
 
       if (stateTarget !== this.output.stateTarget) {
@@ -579,14 +601,24 @@ export const Service = Resource(
     const password = response.password!;
     const service = response.service!;
 
+    const httpEndpoint = service.endpoints!.find(
+      (endpoint) => endpoint.protocol === "https",
+    ) as HttpsEndpoint;
+
     await waitForServiceState(
       api,
       organizationId,
       response.service!.id!,
       (state) => state === "running" || state === "idle",
-      10 * 60,
     );
 
+    if (waitForHttpEndpointReady && httpEndpoint) {
+      await waitForHttpServiceReady(httpEndpoint as HttpsEndpoint, {
+        password: password!,
+        username: "default",
+      });
+    }
+
     return {
       organizationId: organizationId,
       name: service.name!,
@@ -614,13 +646,11 @@ export const Service = Resource(
       state: service.state,
       mysqlEndpoint: service.endpoints!.find(
         (endpoint) => endpoint.protocol === "mysql",
-      ) as any,
-      httpsEndpoint: service.endpoints!.find(
-        (endpoint) => endpoint.protocol === "https",
-      ) as any,
+      ) as MysqlEndpoint,
+      httpsEndpoint: httpEndpoint,
       nativesecureEndpoint: service.endpoints!.find(
         (endpoint) => endpoint.protocol === "nativesecure",
-      ) as any,
+      ) as NativesecureEndpoint,
     };
   },
 );
@@ -630,9 +660,8 @@ async function waitForServiceState(
   organizationId: string,
   serviceId: string,
   stateChecker: (state: string) => boolean,
-  maxWaitSeconds: number,
 ) {
-  const checkState = async (): Promise<void> => {
+  async function checkState(): Promise<void> {
     const service = await api.getServiceDetails({
       path: {
         organizationId: organizationId,
@@ -646,8 +675,70 @@ async function waitForServiceState(
     }
 
     throw new Error(`Service ${serviceId} is in state ${serviceState}`);
-  };
+  }
+
+  await waitFor(checkState, 10 * 60);
+}
 
+async function waitForHttpServiceReady(
+  endpoint: {
+    protocol: "https";
+    host: string;
+    port: number;
+  },
+  credentials: { password: string; username: string },
+) {
+  async function checkHttpEndpoint() {
+    await fetch(
+      `https://${endpoint.host}:${endpoint.port}/?query=SELECT%20count%28%29%20FROM%20system.databases%20WHERE%20name%20%3D%20%27default%27`,
+      {
+        headers: {
+          Authorization: `Basic ${btoa(`${credentials.username}:${credentials.password}`)}`,
+        },
+      },
+    )
+      .then((res) => res.text())
+      .then((text) => {
+        if (text === "0") {
+          throw new Error("Service is not ready");
+        }
+        return;
+      });
+  }
+
+  await waitFor(checkHttpEndpoint, 10 * 60);
+}
+
+async function waitForServiceDeletion(
+  api: ClickhouseClient,
+  organizationId: string,
+  serviceId: string,
+) {
+  async function checkDeletion() {
+    const status = await api
+      .getServiceDetails({
+        path: {
+          organizationId: organizationId,
+          serviceId: serviceId,
+        },
+      })
+      .then((service) => service.response.status)
+      .catch((error) => {
+        return (error.status as number) ?? 500;
+      });
+    if (status === 404) {
+      return;
+    }
+    throw new Error(`Service ${serviceId} is not deleted`);
+  }
+
+  await waitFor(checkDeletion, 10 * 60);
+}
+
+async function waitFor(
+  checkFunction: () => Promise<void>,
+  maxWaitSeconds: number,
+) {
   if (maxWaitSeconds < 5) {
     maxWaitSeconds = 5;
   }
@@ -656,7 +747,7 @@ async function waitForServiceState(
 
   for (let attempt = 0; attempt < maxRetries; attempt++) {
     try {
-      await checkState();
+      await checkFunction();
       return;
     } catch (error) {
       if (attempt === maxRetries - 1) {

package/src/cloudflare/account-api-token.ts

@@ -282,7 +282,7 @@ export const AccountApiToken = Resource(
       return this.destroy();
     }
 
-    const permissionGroups = await PermissionGroups(props);
+    const permissionGroups = await PermissionGroups();
 
     // Transform our properties to API format
     const apiPayload = {

package/src/cloudflare/api.ts

@@ -1,4 +1,5 @@
 import { Provider, type Credentials } from "../auth.ts";
+import { Scope } from "../scope.ts";
 import type { Secret } from "../secret.ts";
 import { isBinary } from "../serde.ts";
 import { memoize } from "../util/memoize.ts";
@@ -99,6 +100,7 @@ export const createCloudflareApi = memoize(
     try {
       const profile =
         options.profile ??
+        Scope.getScope()?.profile ??
         process.env.CLOUDFLARE_PROFILE ??
         process.env.ALCHEMY_PROFILE ??
         "default";

package/src/cloudflare/bun-spa/bun-spa.ts

@@ -2,7 +2,6 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { Scope } from "../../scope.ts";
 import { exists } from "../../util/exists.ts";
-import type { Assets } from "../assets.ts";
 import type { Bindings } from "../bindings.ts";
 import {
   extractStringAndSecretBindings,
@@ -14,21 +13,18 @@ import {
   Website,
   type WebsiteProps,
 } from "../website.ts";
-import type { Worker } from "../worker.ts";
 
 export interface BunSPAProps<B extends Bindings> extends WebsiteProps<B> {
   frontend: string;
   outDir?: string;
 }
 
-export type BunSPA<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type BunSPA<B extends Bindings> = Website<B> & { apiUrl: string };
 
 export async function BunSPA<B extends Bindings>(
   id: string,
   props: BunSPAProps<B>,
-): Promise<BunSPA<B>> {
+): Promise<BunSPA<B> & { apiUrl: string }> {
   const frontendPath = path.resolve(props.frontend);
   if (!(await exists(frontendPath))) {
     throw new Error(`Frontend path ${frontendPath} does not exist`);
@@ -66,6 +62,7 @@ export async function BunSPA<B extends Bindings>(
     ),
   });
 
+  let apiUrl = website.url!;
   // in dev
   if (scope.local) {
     const cwd = props.cwd ?? process.cwd();
@@ -74,7 +71,6 @@ export async function BunSPA<B extends Bindings>(
       props,
       `bun '${path.relative(cwd, frontendPath)}'`,
     );
-    console.log("backend url", website.url);
     const secrets = props.wrangler?.secrets ?? !props.wrangler?.path;
     const env = {
       ...(process.env ?? {}),
@@ -101,11 +97,11 @@ export async function BunSPA<B extends Bindings>(
         ...process.env,
         NODE_ENV: "development",
         ALCHEMY_ROOT: Scope.current.rootDir,
-        PUBLIC_BACKEND_URL: website.url!,
+        PUBLIC_BACKEND_URL: apiUrl,
       },
     });
   }
-  return website;
+  return { ...website, apiUrl } as BunSPA<B>;
 }
 
 async function validateBunfigToml(cwd: string): Promise<void> {

package/src/cloudflare/d1-database.ts

@@ -113,7 +113,7 @@ export interface D1DatabaseProps extends CloudflareApiOptions {
      * Set when `Scope.local` is true to force update to the database even if it was already deployed live.
      * @internal
      */
-    force?: boolean;
+    force?: boolean | number;
   };
 }
 
@@ -250,7 +250,7 @@ export async function D1Database(
       ...(props.dev ?? {}),
       // force local migrations to run even if the database was already deployed live
       // this property will oscillate from true to false depending on the dev vs live deployment
-      force: Scope.current.local,
+      force: Scope.current.local ? Date.now() : false,
     },
   });
 }

package/src/cloudflare/miniflare/build-worker-options.ts

@@ -1,6 +1,7 @@
 import * as miniflare from "miniflare";
 import { assertNever } from "../../util/assert-never.ts";
 import type { HTTPServer } from "../../util/http.ts";
+import { logger } from "../../util/logger.ts";
 import type { CloudflareApi } from "../api.ts";
 import type {
   Binding,
@@ -79,10 +80,7 @@ export const buildWorkerOptions = async (
     ],
     containerEngine: {
       localDocker: {
-        socketPath:
-          process.platform === "win32"
-            ? "//./pipe/docker_engine"
-            : "unix:///var/run/docker.sock",
+        socketPath: await getDockerSocketPath(),
       },
     },
     // This exposes the worker as a route that can be accessed by setting the MF-Route-Override header.
@@ -480,3 +478,33 @@ const isRemoteBinding = (binding: Binding) => {
     !!binding.dev.remote
   );
 };
+
+/**
+ * DOCKER_HOST env is standardized
+ * docker has an option to expose on tcp://localhost:2375; so we check 2375 if the user has it enabled
+ * the pipe on windows doesn't work half the time(even though the pipe exists). This seems like a strange error on how miniflare parses the pipe
+ * @returns The Docker path
+ */
+async function getDockerSocketPath() {
+  if (process.env.DOCKER_HOST) {
+    return process.env.DOCKER_HOST;
+  }
+  // Check if docker is running on tcp://localhost:2375 using fetch
+  try {
+    const url = "http://localhost:2375/_ping";
+    const res = await fetch(url, { method: "GET" });
+    if (res.ok) {
+      const text = await res.text();
+      if (text.trim() === "OK") {
+        return "localhost:2375";
+      }
+    }
+  } catch {}
+  if (process.platform === "win32") {
+    logger.warn(
+      "Using the pipe on Windows is unstable. If you have issues, try setting DOCKER_HOST or enabling 'Expose daemon on tcp://localhost:2375 without TLS' in docker desktop",
+    );
+    return "//./pipe/docker_engine";
+  }
+  return "unix:///var/run/docker.sock";
+}