@distilled.cloud/prisma-postgres 0.0.0 → 0.2.5-alpha2

package/src/operations/getV1WorkspacesByWorkspaceIdIntegrations.ts

@@ -0,0 +1,59 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1WorkspacesByWorkspaceIdIntegrationsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    workspaceId: Schema.String.pipe(T.PathParam()),
+    cursor: Schema.optional(Schema.String),
+    limit: Schema.optional(Schema.Number),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v1/workspaces/{workspaceId}/integrations",
+    }),
+  );
+export type GetV1WorkspacesByWorkspaceIdIntegrationsInput =
+  typeof GetV1WorkspacesByWorkspaceIdIntegrationsInput.Type;
+
+// Output Schema
+export const GetV1WorkspacesByWorkspaceIdIntegrationsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Array(
+      Schema.Struct({
+        id: Schema.String,
+        url: Schema.String,
+        createdAt: Schema.String,
+        scopes: Schema.Array(Schema.String),
+        client: Schema.Struct({
+          id: Schema.String,
+          name: Schema.String,
+          createdAt: Schema.String,
+        }),
+        createdByUser: Schema.Struct({
+          id: Schema.String,
+          email: Schema.String,
+          displayName: Schema.NullOr(Schema.String),
+        }),
+      }),
+    ),
+    pagination: Schema.Struct({
+      nextCursor: Schema.NullOr(Schema.String),
+      hasMore: Schema.Boolean,
+    }),
+  });
+export type GetV1WorkspacesByWorkspaceIdIntegrationsOutput =
+  typeof GetV1WorkspacesByWorkspaceIdIntegrationsOutput.Type;
+
+// The operation
+/**
+ * Get list of integrations
+ *
+ * Returns integrations for the given workspace.
+ */
+export const getV1WorkspacesByWorkspaceIdIntegrations =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: GetV1WorkspacesByWorkspaceIdIntegrationsInput,
+    outputSchema: GetV1WorkspacesByWorkspaceIdIntegrationsOutput,
+  }));

package/src/operations/index.ts

@@ -0,0 +1,31 @@
+export * from "./getV1Connections";
+export * from "./postV1Connections";
+export * from "./getV1ConnectionsById";
+export * from "./deleteV1ConnectionsById";
+export * from "./getV1Databases";
+export * from "./postV1Databases";
+export * from "./getV1DatabasesByDatabaseId";
+export * from "./patchV1DatabasesByDatabaseId";
+export * from "./deleteV1DatabasesByDatabaseId";
+export * from "./getV1DatabasesByDatabaseIdConnections";
+export * from "./postV1DatabasesByDatabaseIdConnections";
+export * from "./getV1DatabasesByDatabaseIdBackups";
+export * from "./getV1DatabasesByDatabaseIdUsage";
+export * from "./getV1Projects";
+export * from "./postV1Projects";
+export * from "./getV1ProjectsById";
+export * from "./patchV1ProjectsById";
+export * from "./deleteV1ProjectsById";
+export * from "./postV1ProjectsByIdTransfer";
+export * from "./getV1ProjectsByProjectIdDatabases";
+export * from "./postV1ProjectsByProjectIdDatabases";
+export * from "./getV1Integrations";
+export * from "./getV1IntegrationsById";
+export * from "./deleteV1IntegrationsById";
+export * from "./getV1WorkspacesByWorkspaceIdIntegrations";
+export * from "./deleteV1WorkspacesByWorkspaceIdIntegrationsByClientId";
+export * from "./getV1Regions";
+export * from "./getV1RegionsPostgres";
+export * from "./getV1RegionsAccelerate";
+export * from "./getV1Workspaces";
+export * from "./getV1WorkspacesById";

package/src/operations/patchV1DatabasesByDatabaseId.ts

@@ -0,0 +1,101 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const PatchV1DatabasesByDatabaseIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    databaseId: Schema.String.pipe(T.PathParam()),
+    name: Schema.optional(Schema.String),
+  }).pipe(T.Http({ method: "PATCH", path: "/v1/databases/{databaseId}" }));
+export type PatchV1DatabasesByDatabaseIdInput =
+  typeof PatchV1DatabasesByDatabaseIdInput.Type;
+
+// Output Schema
+export const PatchV1DatabasesByDatabaseIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+      status: Schema.Literals([
+        "failure",
+        "provisioning",
+        "ready",
+        "recovering",
+      ]),
+      createdAt: Schema.String,
+      isDefault: Schema.Boolean,
+      defaultConnectionId: Schema.NullOr(Schema.String),
+      connections: Schema.Array(
+        Schema.Struct({
+          id: Schema.String,
+          type: Schema.String,
+          url: Schema.String,
+          name: Schema.String,
+          createdAt: Schema.String,
+          kind: Schema.Literals(["postgres", "accelerate"]),
+          endpoints: Schema.Struct({
+            direct: Schema.optional(
+              Schema.Struct({
+                host: Schema.String,
+                port: Schema.Number,
+              }),
+            ),
+            pooled: Schema.optional(
+              Schema.Struct({
+                host: Schema.String,
+                port: Schema.Number,
+              }),
+            ),
+            accelerate: Schema.optional(
+              Schema.Struct({
+                host: Schema.String,
+                port: Schema.Number,
+              }),
+            ),
+          }),
+          directConnection: Schema.optional(
+            Schema.NullOr(
+              Schema.Struct({
+                host: Schema.String,
+                pass: Schema.String,
+                user: Schema.String,
+              }),
+            ),
+          ),
+          database: Schema.Struct({
+            id: Schema.String,
+            url: Schema.String,
+            name: Schema.String,
+          }),
+        }),
+      ),
+      project: Schema.Struct({
+        id: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+      }),
+      region: Schema.NullOr(
+        Schema.Struct({
+          id: Schema.String,
+          name: Schema.String,
+        }),
+      ),
+    }),
+  });
+export type PatchV1DatabasesByDatabaseIdOutput =
+  typeof PatchV1DatabasesByDatabaseIdOutput.Type;
+
+// The operation
+/**
+ * Update database
+ *
+ * Updates the database with the given ID.
+ */
+export const patchV1DatabasesByDatabaseId =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: PatchV1DatabasesByDatabaseIdInput,
+    outputSchema: PatchV1DatabasesByDatabaseIdOutput,
+  }));

package/src/operations/patchV1ProjectsById.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const PatchV1ProjectsByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+    name: Schema.optional(Schema.String),
+    settings: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+  }).pipe(T.Http({ method: "PATCH", path: "/v1/projects/{id}" }));
+export type PatchV1ProjectsByIdInput = typeof PatchV1ProjectsByIdInput.Type;
+
+// Output Schema
+export const PatchV1ProjectsByIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+      createdAt: Schema.String,
+      defaultRegion: Schema.NullOr(Schema.String),
+      workspace: Schema.Struct({
+        id: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+      }),
+    }),
+  });
+export type PatchV1ProjectsByIdOutput = typeof PatchV1ProjectsByIdOutput.Type;
+
+// The operation
+/**
+ * Update project
+ *
+ * Updates the project with the given ID.
+ */
+export const patchV1ProjectsById = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: PatchV1ProjectsByIdInput,
+  outputSchema: PatchV1ProjectsByIdOutput,
+}));

package/src/operations/postV1Connections.ts

@@ -0,0 +1,75 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const PostV1ConnectionsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    databaseId: Schema.String,
+    name: Schema.String,
+  },
+).pipe(T.Http({ method: "POST", path: "/v1/connections" }));
+export type PostV1ConnectionsInput = typeof PostV1ConnectionsInput.Type;
+
+// Output Schema
+export const PostV1ConnectionsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+      createdAt: Schema.String,
+      kind: Schema.Literals(["postgres", "accelerate"]),
+      endpoints: Schema.Struct({
+        direct: Schema.optional(
+          Schema.Struct({
+            host: Schema.String,
+            port: Schema.Number,
+          }),
+        ),
+        pooled: Schema.optional(
+          Schema.Struct({
+            host: Schema.String,
+            port: Schema.Number,
+          }),
+        ),
+        accelerate: Schema.optional(
+          Schema.Struct({
+            host: Schema.String,
+            port: Schema.Number,
+          }),
+        ),
+      }),
+      connectionString: Schema.String,
+      directConnection: Schema.optional(
+        Schema.NullOr(
+          Schema.Struct({
+            host: Schema.String,
+            pass: Schema.String,
+            user: Schema.String,
+          }),
+        ),
+      ),
+      database: Schema.Struct({
+        id: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+      }),
+      host: Schema.NullOr(Schema.String),
+      pass: Schema.NullOr(Schema.String),
+      user: Schema.NullOr(Schema.String),
+    }),
+  });
+export type PostV1ConnectionsOutput = typeof PostV1ConnectionsOutput.Type;
+
+// The operation
+/**
+ * Create connection
+ *
+ * Creates a new connection for the specified database.
+ */
+export const postV1Connections = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: PostV1ConnectionsInput,
+  outputSchema: PostV1ConnectionsOutput,
+}));

package/src/operations/postV1Databases.ts

@@ -0,0 +1,103 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const PostV1DatabasesInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  projectId: Schema.String,
+  region: Schema.optional(
+    Schema.Literals([
+      "us-east-1",
+      "us-west-1",
+      "eu-west-3",
+      "eu-central-1",
+      "ap-northeast-1",
+      "ap-southeast-1",
+      "inherit",
+    ]),
+  ),
+  name: Schema.optional(Schema.String),
+  isDefault: Schema.optional(Schema.Boolean),
+}).pipe(T.Http({ method: "POST", path: "/v1/databases" }));
+export type PostV1DatabasesInput = typeof PostV1DatabasesInput.Type;
+
+// Output Schema
+export const PostV1DatabasesOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  data: Schema.Struct({
+    id: Schema.String,
+    type: Schema.String,
+    url: Schema.String,
+    name: Schema.String,
+    status: Schema.Literals(["failure", "provisioning", "ready", "recovering"]),
+    createdAt: Schema.String,
+    isDefault: Schema.Boolean,
+    defaultConnectionId: Schema.NullOr(Schema.String),
+    connections: Schema.Array(
+      Schema.Struct({
+        id: Schema.String,
+        type: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+        createdAt: Schema.String,
+        kind: Schema.Literals(["postgres", "accelerate"]),
+        endpoints: Schema.Struct({
+          direct: Schema.optional(
+            Schema.Struct({
+              host: Schema.String,
+              port: Schema.Number,
+            }),
+          ),
+          pooled: Schema.optional(
+            Schema.Struct({
+              host: Schema.String,
+              port: Schema.Number,
+            }),
+          ),
+          accelerate: Schema.optional(
+            Schema.Struct({
+              host: Schema.String,
+              port: Schema.Number,
+            }),
+          ),
+        }),
+        directConnection: Schema.optional(
+          Schema.NullOr(
+            Schema.Struct({
+              host: Schema.String,
+              pass: Schema.String,
+              user: Schema.String,
+            }),
+          ),
+        ),
+        database: Schema.Struct({
+          id: Schema.String,
+          url: Schema.String,
+          name: Schema.String,
+        }),
+      }),
+    ),
+    project: Schema.Struct({
+      id: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+    }),
+    region: Schema.NullOr(
+      Schema.Struct({
+        id: Schema.String,
+        name: Schema.String,
+      }),
+    ),
+  }),
+});
+export type PostV1DatabasesOutput = typeof PostV1DatabasesOutput.Type;
+
+// The operation
+/**
+ * Create database
+ *
+ * Creates a new database in the specified project.
+ */
+export const postV1Databases = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: PostV1DatabasesInput,
+  outputSchema: PostV1DatabasesOutput,
+}));

package/src/operations/postV1DatabasesByDatabaseIdConnections.ts

@@ -0,0 +1,82 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const PostV1DatabasesByDatabaseIdConnectionsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    databaseId: Schema.String.pipe(T.PathParam()),
+    name: Schema.String,
+  }).pipe(
+    T.Http({ method: "POST", path: "/v1/databases/{databaseId}/connections" }),
+  );
+export type PostV1DatabasesByDatabaseIdConnectionsInput =
+  typeof PostV1DatabasesByDatabaseIdConnectionsInput.Type;
+
+// Output Schema
+export const PostV1DatabasesByDatabaseIdConnectionsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+      createdAt: Schema.String,
+      kind: Schema.Literals(["postgres", "accelerate"]),
+      endpoints: Schema.Struct({
+        direct: Schema.optional(
+          Schema.Struct({
+            host: Schema.String,
+            port: Schema.Number,
+            connectionString: Schema.String,
+          }),
+        ),
+        pooled: Schema.optional(
+          Schema.Struct({
+            host: Schema.String,
+            port: Schema.Number,
+            connectionString: Schema.String,
+          }),
+        ),
+        accelerate: Schema.optional(
+          Schema.Struct({
+            host: Schema.String,
+            port: Schema.Number,
+            connectionString: Schema.String,
+          }),
+        ),
+      }),
+      connectionString: Schema.String,
+      directConnection: Schema.optional(
+        Schema.NullOr(
+          Schema.Struct({
+            host: Schema.String,
+            pass: Schema.String,
+            user: Schema.String,
+          }),
+        ),
+      ),
+      database: Schema.Struct({
+        id: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+      }),
+      host: Schema.NullOr(Schema.String),
+      pass: Schema.NullOr(Schema.String),
+      user: Schema.NullOr(Schema.String),
+    }),
+  });
+export type PostV1DatabasesByDatabaseIdConnectionsOutput =
+  typeof PostV1DatabasesByDatabaseIdConnectionsOutput.Type;
+
+// The operation
+/**
+ * Create database connection string
+ *
+ * Creates a new connection string for the given database.
+ */
+export const postV1DatabasesByDatabaseIdConnections =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: PostV1DatabasesByDatabaseIdConnectionsInput,
+    outputSchema: PostV1DatabasesByDatabaseIdConnectionsOutput,
+  }));

package/src/operations/postV1Projects.ts

@@ -0,0 +1,160 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const PostV1ProjectsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  createDatabase: Schema.optional(Schema.Boolean),
+  name: Schema.optional(Schema.String),
+  region: Schema.optional(
+    Schema.Literals([
+      "us-east-1",
+      "us-west-1",
+      "eu-west-3",
+      "eu-central-1",
+      "ap-northeast-1",
+      "ap-southeast-1",
+    ]),
+  ),
+}).pipe(T.Http({ method: "POST", path: "/v1/projects" }));
+export type PostV1ProjectsInput = typeof PostV1ProjectsInput.Type;
+
+// Output Schema
+export const PostV1ProjectsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  data: Schema.Struct({
+    id: Schema.String,
+    type: Schema.String,
+    url: Schema.String,
+    name: Schema.String,
+    createdAt: Schema.String,
+    defaultRegion: Schema.NullOr(Schema.String),
+    workspace: Schema.Struct({
+      id: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+    }),
+    database: Schema.NullOr(
+      Schema.Struct({
+        id: Schema.String,
+        type: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+        status: Schema.Literals(["provisioning", "ready"]),
+        createdAt: Schema.String,
+        isDefault: Schema.Boolean,
+        defaultConnectionId: Schema.NullOr(Schema.String),
+        connections: Schema.Array(
+          Schema.Struct({
+            id: Schema.String,
+            type: Schema.String,
+            url: Schema.String,
+            name: Schema.String,
+            createdAt: Schema.String,
+            kind: Schema.Literals(["postgres", "accelerate"]),
+            endpoints: Schema.Struct({
+              direct: Schema.optional(
+                Schema.Struct({
+                  host: Schema.String,
+                  port: Schema.Number,
+                  connectionString: Schema.optional(Schema.String),
+                }),
+              ),
+              pooled: Schema.optional(
+                Schema.Struct({
+                  host: Schema.String,
+                  port: Schema.Number,
+                  connectionString: Schema.optional(Schema.String),
+                }),
+              ),
+              accelerate: Schema.optional(
+                Schema.Struct({
+                  host: Schema.String,
+                  port: Schema.Number,
+                  connectionString: Schema.optional(Schema.String),
+                }),
+              ),
+            }),
+            directConnection: Schema.optional(
+              Schema.NullOr(
+                Schema.Struct({
+                  host: Schema.String,
+                  pass: Schema.String,
+                  user: Schema.String,
+                }),
+              ),
+            ),
+            database: Schema.Struct({
+              id: Schema.String,
+              url: Schema.String,
+              name: Schema.String,
+            }),
+          }),
+        ),
+        region: Schema.Struct({
+          id: Schema.String,
+          name: Schema.String,
+        }),
+        apiKeys: Schema.Array(
+          Schema.Struct({
+            id: Schema.String,
+            type: Schema.String,
+            url: Schema.String,
+            name: Schema.String,
+            createdAt: Schema.String,
+            kind: Schema.Literals(["postgres", "accelerate"]),
+            endpoints: Schema.Struct({
+              direct: Schema.optional(
+                Schema.Struct({
+                  host: Schema.String,
+                  port: Schema.Number,
+                }),
+              ),
+              pooled: Schema.optional(
+                Schema.Struct({
+                  host: Schema.String,
+                  port: Schema.Number,
+                }),
+              ),
+              accelerate: Schema.optional(
+                Schema.Struct({
+                  host: Schema.String,
+                  port: Schema.Number,
+                }),
+              ),
+            }),
+            connectionString: Schema.String,
+            directConnection: Schema.optional(
+              Schema.NullOr(
+                Schema.Struct({
+                  host: Schema.String,
+                  pass: Schema.String,
+                  user: Schema.String,
+                }),
+              ),
+            ),
+          }),
+        ),
+        connectionString: Schema.NullOr(Schema.String),
+        directConnection: Schema.NullOr(
+          Schema.Struct({
+            host: Schema.String,
+            pass: Schema.String,
+            user: Schema.String,
+          }),
+        ),
+      }),
+    ),
+  }),
+});
+export type PostV1ProjectsOutput = typeof PostV1ProjectsOutput.Type;
+
+// The operation
+/**
+ * Create project with a postgres database
+ *
+ * Creates a new project with a postgres database.
+ */
+export const postV1Projects = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: PostV1ProjectsInput,
+  outputSchema: PostV1ProjectsOutput,
+}));

package/src/operations/postV1ProjectsByIdTransfer.ts

@@ -0,0 +1,31 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const PostV1ProjectsByIdTransferInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+    recipientAccessToken: Schema.String,
+  }).pipe(T.Http({ method: "POST", path: "/v1/projects/{id}/transfer" }));
+export type PostV1ProjectsByIdTransferInput =
+  typeof PostV1ProjectsByIdTransferInput.Type;
+
+// Output Schema
+export const PostV1ProjectsByIdTransferOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type PostV1ProjectsByIdTransferOutput =
+  typeof PostV1ProjectsByIdTransferOutput.Type;
+
+// The operation
+/**
+ * Transfer project
+ *
+ * Transfer the project with the given ID to the new owner's workspace
+ */
+export const postV1ProjectsByIdTransfer = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: PostV1ProjectsByIdTransferInput,
+    outputSchema: PostV1ProjectsByIdTransferOutput,
+  }),
+);