@distilled.cloud/planetscale 0.0.0 → 0.2.0-alpha

package/src/operations/createPassword.ts

@@ -0,0 +1,92 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+import { Forbidden, NotFound, UnprocessableEntity } from "../errors";
+import { SensitiveNullableString } from "../sensitive";
+
+// Input Schema
+export const CreatePasswordInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  organization: Schema.String.pipe(T.PathParam()),
+  database: Schema.String.pipe(T.PathParam()),
+  branch: Schema.String.pipe(T.PathParam()),
+  name: Schema.optional(Schema.String),
+  role: Schema.optional(
+    Schema.Literals(["reader", "writer", "admin", "readwriter"]),
+  ),
+  replica: Schema.optional(Schema.Boolean),
+  ttl: Schema.optional(Schema.Number),
+  cidrs: Schema.optional(Schema.Array(Schema.String)),
+  direct_vtgate: Schema.optional(Schema.Boolean),
+}).pipe(
+  T.Http({
+    method: "POST",
+    path: "/organizations/{organization}/databases/{database}/branches/{branch}/passwords",
+  }),
+);
+export type CreatePasswordInput = typeof CreatePasswordInput.Type;
+
+// Output Schema
+export const CreatePasswordOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String,
+  name: Schema.String,
+  role: Schema.Literals(["reader", "writer", "admin", "readwriter"]),
+  cidrs: Schema.NullOr(Schema.Array(Schema.String)),
+  created_at: Schema.String,
+  deleted_at: Schema.NullOr(Schema.String),
+  expires_at: Schema.NullOr(Schema.String),
+  last_used_at: Schema.NullOr(Schema.String),
+  expired: Schema.Boolean,
+  direct_vtgate: Schema.Boolean,
+  direct_vtgate_addresses: Schema.Array(Schema.String),
+  ttl_seconds: Schema.NullOr(Schema.Number),
+  access_host_url: Schema.String,
+  access_host_regional_url: Schema.String,
+  access_host_regional_urls: Schema.Array(Schema.String),
+  actor: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  region: Schema.Struct({
+    id: Schema.String,
+    provider: Schema.String,
+    enabled: Schema.Boolean,
+    public_ip_addresses: Schema.Array(Schema.String),
+    display_name: Schema.String,
+    location: Schema.String,
+    slug: Schema.String,
+    current_default: Schema.Boolean,
+  }),
+  username: Schema.String,
+  plain_text: SensitiveNullableString,
+  replica: Schema.Boolean,
+  renewable: Schema.Boolean,
+  database_branch: Schema.Struct({
+    name: Schema.String,
+    id: Schema.String,
+    production: Schema.Boolean,
+    mysql_edge_address: Schema.String,
+    private_edge_connectivity: Schema.Boolean,
+  }),
+});
+export type CreatePasswordOutput = typeof CreatePasswordOutput.Type;
+
+// The operation
+/**
+ * Create a password
+ *
+ * @param organization - The name of the organization the password belongs to
+ * @param database - The name of the database the password belongs to
+ * @param branch - The name of the branch the password belongs to
+ * @param name - Optional name of the password
+ * @param role - The database role of the password (i.e. admin)
+ * @param replica - Whether the password is for a read replica
+ * @param ttl - Time to live (in seconds) for the password. The password will be invalid when TTL has passed
+ * @param cidrs - List of IP addresses or CIDR ranges that can use this password
+ * @param direct_vtgate - Whether the password connects directly to a VTGate
+ */
+export const createPassword = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: CreatePasswordInput,
+  outputSchema: CreatePasswordOutput,
+  errors: [Forbidden, NotFound, UnprocessableEntity] as const,
+}));

package/src/operations/createQueryPatternsReport.ts

@@ -0,0 +1,53 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+import { Forbidden, NotFound } from "../errors";
+
+// Input Schema
+export const CreateQueryPatternsReportInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organization: Schema.String.pipe(T.PathParam()),
+    database: Schema.String.pipe(T.PathParam()),
+    branch: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/organizations/{organization}/databases/{database}/branches/{branch}/query-patterns",
+    }),
+  );
+export type CreateQueryPatternsReportInput =
+  typeof CreateQueryPatternsReportInput.Type;
+
+// Output Schema
+export const CreateQueryPatternsReportOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    state: Schema.Literals(["pending", "completed", "failed"]),
+    created_at: Schema.String,
+    finished_at: Schema.String,
+    url: Schema.String,
+    download_url: Schema.String,
+    actor: Schema.Struct({
+      id: Schema.String,
+      display_name: Schema.String,
+      avatar_url: Schema.String,
+    }),
+  });
+export type CreateQueryPatternsReportOutput =
+  typeof CreateQueryPatternsReportOutput.Type;
+
+// The operation
+/**
+ * Create a new query patterns report
+ *
+ * @param organization - The name of the organization the branch belongs to
+ * @param database - The name of the database the branch belongs to
+ * @param branch - The name of the branch
+ */
+export const createQueryPatternsReport = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateQueryPatternsReportInput,
+    outputSchema: CreateQueryPatternsReportOutput,
+    errors: [Forbidden, NotFound] as const,
+  }),
+);

package/src/operations/createRole.ts

@@ -0,0 +1,115 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+import { Forbidden, NotFound } from "../errors";
+
+// Input Schema
+export const CreateRoleInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  organization: Schema.String.pipe(T.PathParam()),
+  database: Schema.String.pipe(T.PathParam()),
+  branch: Schema.String.pipe(T.PathParam()),
+  name: Schema.optional(Schema.String),
+  ttl: Schema.optional(Schema.Number),
+  inherited_roles: Schema.optional(
+    Schema.Array(
+      Schema.Literals([
+        "pscale_managed",
+        "pg_checkpoint",
+        "pg_create_subscription",
+        "pg_maintain",
+        "pg_monitor",
+        "pg_read_all_data",
+        "pg_read_all_settings",
+        "pg_read_all_stats",
+        "pg_signal_backend",
+        "pg_stat_scan_tables",
+        "pg_use_reserved_connections",
+        "pg_write_all_data",
+        "postgres",
+      ]),
+    ),
+  ),
+  require_where_on_delete: Schema.optional(Schema.String),
+  require_where_on_update: Schema.optional(Schema.String),
+}).pipe(
+  T.Http({
+    method: "POST",
+    path: "/organizations/{organization}/databases/{database}/branches/{branch}/roles",
+  }),
+);
+export type CreateRoleInput = typeof CreateRoleInput.Type;
+
+// Output Schema
+export const CreateRoleOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String,
+  name: Schema.String,
+  access_host_url: Schema.String,
+  private_access_host_url: Schema.String,
+  private_connection_service_name: Schema.String,
+  username: Schema.String,
+  password: Schema.String,
+  database_name: Schema.String,
+  created_at: Schema.String,
+  updated_at: Schema.String,
+  deleted_at: Schema.String,
+  expires_at: Schema.String,
+  dropped_at: Schema.String,
+  disabled_at: Schema.String,
+  drop_failed: Schema.String,
+  expired: Schema.Boolean,
+  default: Schema.Boolean,
+  ttl: Schema.Number,
+  inherited_roles: Schema.Array(
+    Schema.Literals([
+      "pscale_managed",
+      "pg_checkpoint",
+      "pg_create_subscription",
+      "pg_maintain",
+      "pg_monitor",
+      "pg_read_all_data",
+      "pg_read_all_settings",
+      "pg_read_all_stats",
+      "pg_signal_backend",
+      "pg_stat_scan_tables",
+      "pg_use_reserved_connections",
+      "pg_write_all_data",
+      "postgres",
+    ]),
+  ),
+  branch: Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    deleted_at: Schema.String,
+  }),
+  actor: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  query_safety_settings: Schema.Struct({
+    require_where_on_delete: Schema.Literals(["off", "warn", "on"]),
+    require_where_on_update: Schema.Literals(["off", "warn", "on"]),
+  }),
+});
+export type CreateRoleOutput = typeof CreateRoleOutput.Type;
+
+// The operation
+/**
+ * Create role credentials
+ *
+ * @param organization - Organization name slug from `list_organizations`. Example: `acme`.
+ * @param database - Database name slug from `list_databases`. Example: `app-db`.
+ * @param branch - Branch name from `list_branches`. Example: `main`.
+ * @param name - The name of the role
+ * @param ttl - Time to live in seconds
+ * @param inherited_roles - Roles to inherit from
+ * @param require_where_on_delete - Require WHERE clause on DELETE statements
+ * @param require_where_on_update - Require WHERE clause on UPDATE statements
+ */
+export const createRole = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: CreateRoleInput,
+  outputSchema: CreateRoleOutput,
+  errors: [Forbidden, NotFound] as const,
+}));

package/src/operations/createServiceToken.ts

@@ -0,0 +1,135 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+import { Forbidden, NotFound } from "../errors";
+import { SensitiveString } from "../sensitive";
+
+// Input Schema
+export const CreateServiceTokenInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organization: Schema.String.pipe(T.PathParam()),
+    name: Schema.optional(Schema.String),
+    ttl: Schema.optional(Schema.Number),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/organizations/{organization}/service-tokens",
+    }),
+  );
+export type CreateServiceTokenInput = typeof CreateServiceTokenInput.Type;
+
+// Output Schema
+export const CreateServiceTokenOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    display_name: Schema.String,
+    token: SensitiveString,
+    plain_text_refresh_token: SensitiveString,
+    avatar_url: Schema.String,
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    expires_at: Schema.String,
+    last_used_at: Schema.String,
+    actor_id: Schema.String,
+    actor_display_name: Schema.String,
+    actor_type: Schema.String,
+    service_token_accesses: Schema.Array(
+      Schema.Struct({
+        id: Schema.String,
+        access: Schema.String,
+        description: Schema.String,
+        resource_name: Schema.String,
+        resource_id: Schema.String,
+        resource_type: Schema.String,
+        resource: Schema.Struct({
+          id: Schema.String,
+          name: Schema.String,
+          created_at: Schema.String,
+          updated_at: Schema.String,
+          deleted_at: Schema.String,
+        }),
+      }),
+    ),
+    oauth_accesses_by_resource: Schema.Struct({
+      database: Schema.Struct({
+        databases: Schema.Array(
+          Schema.Struct({
+            name: Schema.String,
+            id: Schema.String,
+            organization: Schema.String,
+            url: Schema.String,
+          }),
+        ),
+        accesses: Schema.Array(
+          Schema.Struct({
+            name: Schema.String,
+            description: Schema.String,
+          }),
+        ),
+      }),
+      organization: Schema.Struct({
+        organizations: Schema.Array(
+          Schema.Struct({
+            name: Schema.String,
+            id: Schema.String,
+            url: Schema.String,
+          }),
+        ),
+        accesses: Schema.Array(
+          Schema.Struct({
+            name: Schema.String,
+            description: Schema.String,
+          }),
+        ),
+      }),
+      branch: Schema.Struct({
+        branches: Schema.Array(
+          Schema.Struct({
+            name: Schema.String,
+            id: Schema.String,
+            database: Schema.String,
+            organization: Schema.String,
+            url: Schema.String,
+          }),
+        ),
+        accesses: Schema.Array(
+          Schema.Struct({
+            name: Schema.String,
+            description: Schema.String,
+          }),
+        ),
+      }),
+      user: Schema.Struct({
+        users: Schema.Array(
+          Schema.Struct({
+            name: Schema.String,
+            id: Schema.String,
+          }),
+        ),
+        accesses: Schema.Array(
+          Schema.Struct({
+            name: Schema.String,
+            description: Schema.String,
+          }),
+        ),
+      }),
+    }),
+  });
+export type CreateServiceTokenOutput = typeof CreateServiceTokenOutput.Type;
+
+// The operation
+/**
+ * Create a service token
+ *
+ * Create a new service token for the organization.
+ *
+ * @param organization - The name of the organization
+ * @param name - The name of the service token
+ * @param ttl - Time to live (in seconds) for the service token. The token will be invalid when TTL has passed
+ */
+export const createServiceToken = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: CreateServiceTokenInput,
+  outputSchema: CreateServiceTokenOutput,
+  errors: [Forbidden, NotFound] as const,
+}));

package/src/operations/createWebhook.ts

@@ -0,0 +1,72 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+import { Forbidden, NotFound } from "../errors";
+
+// Input Schema
+export const CreateWebhookInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  organization: Schema.String.pipe(T.PathParam()),
+  database: Schema.String.pipe(T.PathParam()),
+  url: Schema.String,
+  enabled: Schema.optional(Schema.Boolean),
+  events: Schema.optional(Schema.Array(Schema.String)),
+}).pipe(
+  T.Http({
+    method: "POST",
+    path: "/organizations/{organization}/databases/{database}/webhooks",
+  }),
+);
+export type CreateWebhookInput = typeof CreateWebhookInput.Type;
+
+// Output Schema
+export const CreateWebhookOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String,
+  url: Schema.String,
+  secret: Schema.String,
+  enabled: Schema.Boolean,
+  last_sent_result: Schema.NullOr(Schema.String),
+  last_sent_success: Schema.NullOr(Schema.Boolean),
+  last_sent_at: Schema.NullOr(Schema.String),
+  created_at: Schema.String,
+  updated_at: Schema.String,
+  events: Schema.Array(
+    Schema.Literals([
+      "branch.ready",
+      "branch.anomaly",
+      "branch.out_of_memory",
+      "branch.primary_promoted",
+      "branch.schema_recommendation",
+      "branch.sleeping",
+      "branch.start_maintenance",
+      "cluster.storage",
+      "database.access_request",
+      "deploy_request.closed",
+      "deploy_request.errored",
+      "deploy_request.in_progress",
+      "deploy_request.opened",
+      "deploy_request.pending_cutover",
+      "deploy_request.queued",
+      "deploy_request.reverted",
+      "deploy_request.schema_applied",
+      "keyspace.storage",
+      "webhook.test",
+    ]),
+  ),
+});
+export type CreateWebhookOutput = typeof CreateWebhookOutput.Type;
+
+// The operation
+/**
+ * Create a webhook
+ *
+ * @param organization - The name of the organization
+ * @param database - The name of the database
+ * @param url - The URL the webhook will send events to
+ * @param enabled - Whether the webhook should be enabled
+ * @param events - The events this webhook should subscribe to
+ */
+export const createWebhook = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: CreateWebhookInput,
+  outputSchema: CreateWebhookOutput,
+  errors: [Forbidden, NotFound] as const,
+}));

package/src/operations/createWorkflow.ts

@@ -0,0 +1,175 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+import { Forbidden, NotFound } from "../errors";
+
+// Input Schema
+export const CreateWorkflowInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  organization: Schema.String.pipe(T.PathParam()),
+  database: Schema.String.pipe(T.PathParam()),
+  name: Schema.String,
+  source_keyspace: Schema.String,
+  target_keyspace: Schema.String,
+  global_keyspace: Schema.optional(Schema.String),
+  defer_secondary_keys: Schema.optional(Schema.Boolean),
+  on_ddl: Schema.optional(
+    Schema.Literals(["IGNORE", "STOP", "EXEC", "EXEC_IGNORE"]),
+  ),
+  tables: Schema.Array(Schema.String),
+}).pipe(
+  T.Http({
+    method: "POST",
+    path: "/organizations/{organization}/databases/{database}/workflows",
+  }),
+);
+export type CreateWorkflowInput = typeof CreateWorkflowInput.Type;
+
+// Output Schema
+export const CreateWorkflowOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String,
+  name: Schema.String,
+  number: Schema.Number,
+  state: Schema.Literals([
+    "pending",
+    "copying",
+    "running",
+    "stopped",
+    "verifying_data",
+    "verified_data",
+    "switching_replicas",
+    "switched_replicas",
+    "switching_primaries",
+    "switched_primaries",
+    "reversing_traffic",
+    "reversing_traffic_for_cancel",
+    "cutting_over",
+    "cutover",
+    "reversed_cutover",
+    "completed",
+    "cancelling",
+    "cancelled",
+    "error",
+  ]),
+  created_at: Schema.String,
+  updated_at: Schema.String,
+  started_at: Schema.String,
+  completed_at: Schema.String,
+  cancelled_at: Schema.String,
+  reversed_at: Schema.String,
+  retried_at: Schema.String,
+  data_copy_completed_at: Schema.String,
+  cutover_at: Schema.String,
+  replicas_switched: Schema.Boolean,
+  primaries_switched: Schema.Boolean,
+  switch_replicas_at: Schema.String,
+  switch_primaries_at: Schema.String,
+  verify_data_at: Schema.String,
+  workflow_type: Schema.Literals(["move_tables"]),
+  workflow_subtype: Schema.String,
+  defer_secondary_keys: Schema.Boolean,
+  on_ddl: Schema.Literals(["IGNORE", "STOP", "EXEC", "EXEC_IGNORE"]),
+  workflow_errors: Schema.String,
+  may_retry: Schema.Boolean,
+  may_restart: Schema.Boolean,
+  verified_data_stale: Schema.Boolean,
+  sequence_tables_applied: Schema.Boolean,
+  actor: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  verify_data_by: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  reversed_by: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  switch_replicas_by: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  switch_primaries_by: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  cancelled_by: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  completed_by: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  retried_by: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  cutover_by: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  reversed_cutover_by: Schema.Struct({
+    id: Schema.String,
+    display_name: Schema.String,
+    avatar_url: Schema.String,
+  }),
+  branch: Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    deleted_at: Schema.String,
+  }),
+  source_keyspace: Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    deleted_at: Schema.String,
+  }),
+  target_keyspace: Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    deleted_at: Schema.String,
+  }),
+  global_keyspace: Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    deleted_at: Schema.String,
+  }),
+});
+export type CreateWorkflowOutput = typeof CreateWorkflowOutput.Type;
+
+// The operation
+/**
+ * Create a workflow
+ *
+ * @param organization - The name of the organization the workflow belongs to
+ * @param database - The name of the database the workflow belongs to
+ * @param name - Name the workflow
+ * @param source_keyspace - Name of the source keyspace
+ * @param target_keyspace - Name of the target keyspace
+ * @param global_keyspace - Name of the global sequence keyspace
+ * @param defer_secondary_keys - Defer secondary keys
+ * @param on_ddl - The behavior when DDL changes during the workflow
+ * @param tables - List of tables to move
+ */
+export const createWorkflow = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: CreateWorkflowInput,
+  outputSchema: CreateWorkflowOutput,
+  errors: [Forbidden, NotFound] as const,
+}));

package/src/operations/deleteBackup.ts

@@ -0,0 +1,37 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+import { Forbidden, NotFound } from "../errors";
+
+// Input Schema
+export const DeleteBackupInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+  organization: Schema.String.pipe(T.PathParam()),
+  database: Schema.String.pipe(T.PathParam()),
+  branch: Schema.String.pipe(T.PathParam()),
+}).pipe(
+  T.Http({
+    method: "DELETE",
+    path: "/organizations/{organization}/databases/{database}/branches/{branch}/backups/{id}",
+  }),
+);
+export type DeleteBackupInput = typeof DeleteBackupInput.Type;
+
+// Output Schema
+export const DeleteBackupOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteBackupOutput = typeof DeleteBackupOutput.Type;
+
+// The operation
+/**
+ * Delete a backup
+ *
+ * @param id - The ID of the backup
+ * @param organization - The name of the organization the branch belongs to
+ * @param database - The name of the database the branch belongs to
+ * @param branch - The name of the branch
+ */
+export const deleteBackup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteBackupInput,
+  outputSchema: DeleteBackupOutput,
+  errors: [Forbidden, NotFound] as const,
+}));