@alchemy.run/turso 0.0.0 → 2.0.0-beta.85

package/src/OrganizationSettings.ts

@@ -0,0 +1,145 @@
+import * as turso from "@distilled.cloud/turso/turso";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import { organization } from "./Credentials.ts";
+import type { Providers } from "./Providers.ts";
+
+export interface OrganizationSettingsProps {
+  /** Allow usage beyond the plan's quota to be billed as overages. */
+  overages?: boolean;
+  /**
+   * Require every member to enable multi-factor authentication. The
+   * deploying user must have MFA enabled first.
+   */
+  requireMfa?: boolean;
+  /**
+   * Keep deleted databases and groups recoverable. Requires an admin or
+   * owner.
+   */
+  restoreEnabled?: boolean;
+}
+
+interface Settings {
+  overages: boolean;
+  requireMfa: boolean;
+  restoreEnabled: boolean;
+}
+
+export interface OrganizationSettingsAttributes extends Settings {
+  /** The organization slug. */
+  organization: string;
+  /** Settings observed before Alchemy first changed them; restored on destroy. */
+  original: Settings;
+}
+
+export type OrganizationSettings = Resource<
+  "Turso.OrganizationSettings",
+  OrganizationSettingsProps,
+  OrganizationSettingsAttributes,
+  never,
+  Providers
+>;
+
+/**
+ * Settings of the Turso organization your credentials act on. Only the
+ * settings you set are managed; destroying the resource restores the values
+ * observed before Alchemy first changed them.
+ * @see https://docs.turso.tech/api-reference/organizations/update
+ *
+ * ### Configuring the Organization
+ * **Example:** Enable overages and require MFA
+ * ```typescript
+ * yield* Turso.OrganizationSettings("Org", {
+ *   overages: true,
+ *   requireMfa: true,
+ * });
+ * ```
+ *
+ * @resource
+ * @product Organization
+ */
+export const OrganizationSettings = Resource<OrganizationSettings>("Turso.OrganizationSettings");
+
+const toSettings = (org: turso.Organization | undefined): Settings => ({
+  overages: org?.overages ?? false,
+  requireMfa: org?.require_mfa ?? false,
+  restoreEnabled: org?.restore_enabled ?? false,
+});
+
+export const OrganizationSettingsProvider = () =>
+  Provider.effect(
+    OrganizationSettings,
+    Effect.gen(function* () {
+      const observe = (slug: string) =>
+        turso
+          .getOrganization({ organizationSlug: slug })
+          .pipe(Effect.map(({ organization }) => toSettings(organization)));
+
+      // `restore_enabled` must be updated on its own (per the API).
+      const apply = (slug: string, observed: Settings, desired: Partial<Settings>) =>
+        Effect.gen(function* () {
+          const patch: { overages?: boolean; require_mfa?: boolean } = {};
+          if (desired.overages !== undefined && desired.overages !== observed.overages) {
+            patch.overages = desired.overages;
+          }
+          if (desired.requireMfa !== undefined && desired.requireMfa !== observed.requireMfa) {
+            patch.require_mfa = desired.requireMfa;
+          }
+          if (Object.keys(patch).length > 0) {
+            yield* turso.updateOrganization({ organizationSlug: slug, ...patch });
+          }
+          if (
+            desired.restoreEnabled !== undefined &&
+            desired.restoreEnabled !== observed.restoreEnabled
+          ) {
+            yield* turso.updateOrganization({
+              organizationSlug: slug,
+              restore_enabled: desired.restoreEnabled,
+            });
+          }
+        });
+
+      return {
+        stables: ["organization", "original"],
+        read: Effect.fn(function* ({ output }) {
+          if (!output) return undefined;
+          return { ...output, ...(yield* observe(output.organization)) };
+        }),
+        reconcile: Effect.fn(function* ({ news, output }) {
+          const slug = output?.organization ?? (yield* organization);
+          const observed = yield* observe(slug);
+          yield* apply(slug, observed, news);
+          // Organization reads can briefly lag a PATCH; wait until the
+          // settings we set are visible.
+          const settled = yield* observe(slug).pipe(
+            Effect.repeat({
+              schedule: Schedule.spaced("1 second"),
+              until: (current) =>
+                (news.overages === undefined || current.overages === news.overages) &&
+                (news.requireMfa === undefined || current.requireMfa === news.requireMfa) &&
+                (news.restoreEnabled === undefined ||
+                  current.restoreEnabled === news.restoreEnabled),
+              times: 10,
+            }),
+          );
+          return {
+            organization: slug,
+            original: output?.original ?? observed,
+            ...settled,
+          };
+        }),
+        delete: Effect.fn(function* ({ olds, output }) {
+          const observed = yield* observe(output.organization);
+          // Restore only the settings this resource managed.
+          yield* apply(output.organization, observed, {
+            overages: olds.overages !== undefined ? output.original.overages : undefined,
+            requireMfa: olds.requireMfa !== undefined ? output.original.requireMfa : undefined,
+            restoreEnabled:
+              olds.restoreEnabled !== undefined ? output.original.restoreEnabled : undefined,
+          });
+        }),
+      };
+    }),
+  );

package/src/Providers.ts

@@ -0,0 +1,67 @@
+import { CredentialsStoreLive } from "alchemy/Auth/Credentials";
+import { ProfileStoreLive } from "alchemy/Auth/Profile";
+import * as Provider from "alchemy/Provider";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as Layer from "effect/Layer";
+import { ApiToken, ApiTokenProvider } from "./ApiToken.ts";
+import { TursoAuth } from "./AuthProvider.ts";
+import * as Credentials from "./Credentials.ts";
+import { Database, DatabaseProvider } from "./Database.ts";
+import { DatabaseToken, DatabaseTokenProvider } from "./DatabaseToken.ts";
+import { Group, GroupProvider } from "./Group.ts";
+import { GroupToken, GroupTokenProvider } from "./GroupToken.ts";
+import { OrganizationInvite, OrganizationInviteProvider } from "./OrganizationInvite.ts";
+import { OrganizationMember, OrganizationMemberProvider } from "./OrganizationMember.ts";
+import { OrganizationSettings, OrganizationSettingsProvider } from "./OrganizationSettings.ts";
+
+/**
+ * Service tag bundling all Turso providers + auth + credentials. Use
+ * `Turso.providers()` to materialize the full layer.
+ */
+export class Providers extends Provider.ProviderCollection<Providers>()("Turso") {}
+
+export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
+
+/**
+ * Build the complete Turso providers Layer: every Turso resource, the
+ * Turso AuthProvider registration (so `alchemy profile edit` can configure
+ * it), and credential resolution.
+ *
+ * @example
+ * ```ts
+ * Alchemy.Stack("App", { providers: Turso.providers() }, ...)
+ * ```
+ */
+export const providers = () =>
+  Layer.effect(
+    Providers,
+    Provider.collection([
+      ApiToken,
+      Database,
+      DatabaseToken,
+      Group,
+      GroupToken,
+      OrganizationInvite,
+      OrganizationMember,
+      OrganizationSettings,
+    ]),
+  ).pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        ApiTokenProvider(),
+        DatabaseProvider(),
+        DatabaseTokenProvider(),
+        GroupProvider(),
+        GroupTokenProvider(),
+        OrganizationInviteProvider(),
+        OrganizationMemberProvider(),
+        OrganizationSettingsProvider(),
+      ),
+    ),
+    Layer.provideMerge(Credentials.fromAuthProvider()),
+    Layer.provideMerge(FetchHttpClient.layer),
+    Layer.provideMerge(TursoAuth),
+    Layer.provideMerge(ProfileStoreLive),
+    Layer.provideMerge(CredentialsStoreLive),
+    Layer.orDie,
+  );

package/src/index.ts

@@ -0,0 +1,20 @@
+export * from "./ApiToken.ts";
+export * from "./AuthProvider.ts";
+export * from "./Connect.ts";
+export {
+  Credentials,
+  CredentialsFromEnv,
+  DEFAULT_API_BASE_URL,
+  fromAuthProvider,
+  fromToken,
+  Organization,
+} from "./Credentials.ts";
+export * from "./Database.ts";
+export * from "./DatabaseToken.ts";
+export * from "./Group.ts";
+export * from "./GroupToken.ts";
+export * from "./ManageDatabases.ts";
+export * from "./OrganizationInvite.ts";
+export * from "./OrganizationMember.ts";
+export * from "./OrganizationSettings.ts";
+export * from "./Providers.ts";