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

package/src/operations/getV1DatabasesByDatabaseIdBackups.ts

@@ -0,0 +1,50 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1DatabasesByDatabaseIdBackupsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    databaseId: Schema.String.pipe(T.PathParam()),
+    limit: Schema.optional(Schema.Number),
+  }).pipe(
+    T.Http({ method: "GET", path: "/v1/databases/{databaseId}/backups" }),
+  );
+export type GetV1DatabasesByDatabaseIdBackupsInput =
+  typeof GetV1DatabasesByDatabaseIdBackupsInput.Type;
+
+// Output Schema
+export const GetV1DatabasesByDatabaseIdBackupsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Array(
+      Schema.Struct({
+        id: Schema.String,
+        backupType: Schema.Literals(["full", "incremental"]),
+        createdAt: Schema.String,
+        size: Schema.optional(Schema.Number),
+        status: Schema.Literals(["running", "completed", "failed", "unknown"]),
+        type: Schema.optional(Schema.String),
+      }),
+    ),
+    meta: Schema.Struct({
+      backupRetentionDays: Schema.Number,
+    }),
+    pagination: Schema.Struct({
+      hasMore: Schema.Boolean,
+      limit: Schema.Unknown,
+    }),
+  });
+export type GetV1DatabasesByDatabaseIdBackupsOutput =
+  typeof GetV1DatabasesByDatabaseIdBackupsOutput.Type;
+
+// The operation
+/**
+ * Get list of backups
+ *
+ * Returns backups for the specified database.
+ */
+export const getV1DatabasesByDatabaseIdBackups =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: GetV1DatabasesByDatabaseIdBackupsInput,
+    outputSchema: GetV1DatabasesByDatabaseIdBackupsOutput,
+  }));

package/src/operations/getV1DatabasesByDatabaseIdConnections.ts

@@ -0,0 +1,82 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1DatabasesByDatabaseIdConnectionsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    databaseId: Schema.String.pipe(T.PathParam()),
+    cursor: Schema.optional(Schema.String),
+    limit: Schema.optional(Schema.Number),
+  }).pipe(
+    T.Http({ method: "GET", path: "/v1/databases/{databaseId}/connections" }),
+  );
+export type GetV1DatabasesByDatabaseIdConnectionsInput =
+  typeof GetV1DatabasesByDatabaseIdConnectionsInput.Type;
+
+// Output Schema
+export const GetV1DatabasesByDatabaseIdConnectionsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: 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,
+        }),
+      }),
+    ),
+    pagination: Schema.Struct({
+      nextCursor: Schema.NullOr(Schema.String),
+      hasMore: Schema.Boolean,
+    }),
+  });
+export type GetV1DatabasesByDatabaseIdConnectionsOutput =
+  typeof GetV1DatabasesByDatabaseIdConnectionsOutput.Type;
+
+// The operation
+/**
+ * Get list of database connections
+ *
+ * Returns all connections for the given database.
+ */
+export const getV1DatabasesByDatabaseIdConnections =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: GetV1DatabasesByDatabaseIdConnectionsInput,
+    outputSchema: GetV1DatabasesByDatabaseIdConnectionsOutput,
+  }));

package/src/operations/getV1DatabasesByDatabaseIdUsage.ts

@@ -0,0 +1,47 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1DatabasesByDatabaseIdUsageInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    databaseId: Schema.String.pipe(T.PathParam()),
+    startDate: Schema.optional(Schema.String),
+    endDate: Schema.optional(Schema.String),
+  }).pipe(T.Http({ method: "GET", path: "/v1/databases/{databaseId}/usage" }));
+export type GetV1DatabasesByDatabaseIdUsageInput =
+  typeof GetV1DatabasesByDatabaseIdUsageInput.Type;
+
+// Output Schema
+export const GetV1DatabasesByDatabaseIdUsageOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    period: Schema.Struct({
+      start: Schema.String,
+      end: Schema.String,
+    }),
+    metrics: Schema.Struct({
+      operations: Schema.Struct({
+        used: Schema.Number,
+        unit: Schema.String,
+      }),
+      storage: Schema.Struct({
+        used: Schema.Number,
+        unit: Schema.String,
+      }),
+    }),
+    generatedAt: Schema.String,
+  });
+export type GetV1DatabasesByDatabaseIdUsageOutput =
+  typeof GetV1DatabasesByDatabaseIdUsageOutput.Type;
+
+// The operation
+/**
+ * Get database usage metrics
+ *
+ * Returns usage metrics for the specified database.
+ */
+export const getV1DatabasesByDatabaseIdUsage =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: GetV1DatabasesByDatabaseIdUsageInput,
+    outputSchema: GetV1DatabasesByDatabaseIdUsageOutput,
+  }));

package/src/operations/getV1Integrations.ts

@@ -0,0 +1,52 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1IntegrationsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    cursor: Schema.optional(Schema.String),
+    limit: Schema.optional(Schema.Number),
+    workspaceId: Schema.String,
+  },
+).pipe(T.Http({ method: "GET", path: "/v1/integrations" }));
+export type GetV1IntegrationsInput = typeof GetV1IntegrationsInput.Type;
+
+// Output Schema
+export const GetV1IntegrationsOutput =
+  /*@__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 GetV1IntegrationsOutput = typeof GetV1IntegrationsOutput.Type;
+
+// The operation
+/**
+ * Get list of integrations
+ *
+ * Returns integrations filtered by workspace ID.
+ */
+export const getV1Integrations = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetV1IntegrationsInput,
+  outputSchema: GetV1IntegrationsOutput,
+}));

package/src/operations/getV1IntegrationsById.ts

@@ -0,0 +1,46 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1IntegrationsByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "GET", path: "/v1/integrations/{id}" }));
+export type GetV1IntegrationsByIdInput = typeof GetV1IntegrationsByIdInput.Type;
+
+// Output Schema
+export const GetV1IntegrationsByIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: 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),
+      }),
+    }),
+  });
+export type GetV1IntegrationsByIdOutput =
+  typeof GetV1IntegrationsByIdOutput.Type;
+
+// The operation
+/**
+ * Get integration by ID
+ *
+ * Returns a single integration by its ID.
+ */
+export const getV1IntegrationsById = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetV1IntegrationsByIdInput,
+    outputSchema: GetV1IntegrationsByIdOutput,
+  }),
+);

package/src/operations/getV1Projects.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1ProjectsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  cursor: Schema.optional(Schema.String),
+  limit: Schema.optional(Schema.Number),
+}).pipe(T.Http({ method: "GET", path: "/v1/projects" }));
+export type GetV1ProjectsInput = typeof GetV1ProjectsInput.Type;
+
+// Output Schema
+export const GetV1ProjectsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  data: Schema.Array(
+    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,
+      }),
+    }),
+  ),
+  pagination: Schema.Struct({
+    nextCursor: Schema.NullOr(Schema.String),
+    hasMore: Schema.Boolean,
+  }),
+});
+export type GetV1ProjectsOutput = typeof GetV1ProjectsOutput.Type;
+
+// The operation
+/**
+ * Get list of projects
+ *
+ * Returns the list of projects the token has access to.
+ */
+export const getV1Projects = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetV1ProjectsInput,
+  outputSchema: GetV1ProjectsOutput,
+}));

package/src/operations/getV1ProjectsById.ts

@@ -0,0 +1,41 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1ProjectsByIdInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    id: Schema.String.pipe(T.PathParam()),
+  },
+).pipe(T.Http({ method: "GET", path: "/v1/projects/{id}" }));
+export type GetV1ProjectsByIdInput = typeof GetV1ProjectsByIdInput.Type;
+
+// Output Schema
+export const GetV1ProjectsByIdOutput =
+  /*@__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 GetV1ProjectsByIdOutput = typeof GetV1ProjectsByIdOutput.Type;
+
+// The operation
+/**
+ * Get project
+ *
+ * Returns the project with the given ID.
+ */
+export const getV1ProjectsById = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetV1ProjectsByIdInput,
+  outputSchema: GetV1ProjectsByIdOutput,
+}));

package/src/operations/getV1ProjectsByProjectIdDatabases.ts

@@ -0,0 +1,110 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1ProjectsByProjectIdDatabasesInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    projectId: Schema.String.pipe(T.PathParam()),
+    cursor: Schema.optional(Schema.String),
+    limit: Schema.optional(Schema.Number),
+  }).pipe(
+    T.Http({ method: "GET", path: "/v1/projects/{projectId}/databases" }),
+  );
+export type GetV1ProjectsByProjectIdDatabasesInput =
+  typeof GetV1ProjectsByProjectIdDatabasesInput.Type;
+
+// Output Schema
+export const GetV1ProjectsByProjectIdDatabasesOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Array(
+      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,
+          }),
+        ),
+      }),
+    ),
+    pagination: Schema.Struct({
+      nextCursor: Schema.NullOr(Schema.String),
+      hasMore: Schema.Boolean,
+    }),
+  });
+export type GetV1ProjectsByProjectIdDatabasesOutput =
+  typeof GetV1ProjectsByProjectIdDatabasesOutput.Type;
+
+// The operation
+/**
+ * Get list of databases
+ *
+ * Returns databases for the given project.
+ */
+export const getV1ProjectsByProjectIdDatabases =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: GetV1ProjectsByProjectIdDatabasesInput,
+    outputSchema: GetV1ProjectsByProjectIdDatabasesOutput,
+  }));

package/src/operations/getV1Regions.ts

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1RegionsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  product: Schema.optional(Schema.Literals(["postgres", "accelerate"])),
+}).pipe(T.Http({ method: "GET", path: "/v1/regions" }));
+export type GetV1RegionsInput = typeof GetV1RegionsInput.Type;
+
+// Output Schema
+export const GetV1RegionsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  data: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      name: Schema.String,
+      product: Schema.Literals(["postgres", "accelerate"]),
+      status: Schema.optional(Schema.Literals(["available", "unavailable"])),
+    }),
+  ),
+});
+export type GetV1RegionsOutput = typeof GetV1RegionsOutput.Type;
+
+// The operation
+/**
+ * Get all regions
+ *
+ * Returns all available regions across products. Optionally filter by product.
+ */
+export const getV1Regions = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetV1RegionsInput,
+  outputSchema: GetV1RegionsOutput,
+}));

package/src/operations/getV1RegionsAccelerate.ts

@@ -0,0 +1,38 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1RegionsAccelerateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
+    T.Http({ method: "GET", path: "/v1/regions/accelerate" }),
+  );
+export type GetV1RegionsAccelerateInput =
+  typeof GetV1RegionsAccelerateInput.Type;
+
+// Output Schema
+export const GetV1RegionsAccelerateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Array(
+      Schema.Struct({
+        id: Schema.String,
+        type: Schema.String,
+        name: Schema.String,
+      }),
+    ),
+  });
+export type GetV1RegionsAccelerateOutput =
+  typeof GetV1RegionsAccelerateOutput.Type;
+
+// The operation
+/**
+ * Get Prisma Accelerate regions
+ *
+ * Returns all available regions for Prisma Accelerate.
+ */
+export const getV1RegionsAccelerate = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetV1RegionsAccelerateInput,
+    outputSchema: GetV1RegionsAccelerateOutput,
+  }),
+);

package/src/operations/getV1RegionsPostgres.ts

@@ -0,0 +1,37 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1RegionsPostgresInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
+    T.Http({ method: "GET", path: "/v1/regions/postgres" }),
+  );
+export type GetV1RegionsPostgresInput = typeof GetV1RegionsPostgresInput.Type;
+
+// Output Schema
+export const GetV1RegionsPostgresOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Array(
+      Schema.Struct({
+        id: Schema.String,
+        type: Schema.String,
+        name: Schema.String,
+        status: Schema.Literals(["available", "unavailable"]),
+      }),
+    ),
+  });
+export type GetV1RegionsPostgresOutput = typeof GetV1RegionsPostgresOutput.Type;
+
+// The operation
+/**
+ * Get Prisma Postgres regions
+ *
+ * Returns all available regions for Prisma Postgres.
+ */
+export const getV1RegionsPostgres = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetV1RegionsPostgresInput,
+    outputSchema: GetV1RegionsPostgresOutput,
+  }),
+);

package/src/operations/getV1Workspaces.ts

@@ -0,0 +1,39 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1WorkspacesInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  cursor: Schema.optional(Schema.String),
+  limit: Schema.optional(Schema.Number),
+}).pipe(T.Http({ method: "GET", path: "/v1/workspaces" }));
+export type GetV1WorkspacesInput = typeof GetV1WorkspacesInput.Type;
+
+// Output Schema
+export const GetV1WorkspacesOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  data: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+      createdAt: Schema.String,
+    }),
+  ),
+  pagination: Schema.Struct({
+    nextCursor: Schema.NullOr(Schema.String),
+    hasMore: Schema.Boolean,
+  }),
+});
+export type GetV1WorkspacesOutput = typeof GetV1WorkspacesOutput.Type;
+
+// The operation
+/**
+ * Get list of workspaces
+ *
+ * Returns the list of workspaces the current token can access.
+ */
+export const getV1Workspaces = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetV1WorkspacesInput,
+  outputSchema: GetV1WorkspacesOutput,
+}));

package/src/operations/getV1WorkspacesById.ts

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1WorkspacesByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "GET", path: "/v1/workspaces/{id}" }));
+export type GetV1WorkspacesByIdInput = typeof GetV1WorkspacesByIdInput.Type;
+
+// Output Schema
+export const GetV1WorkspacesByIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+      createdAt: Schema.String,
+    }),
+  });
+export type GetV1WorkspacesByIdOutput = typeof GetV1WorkspacesByIdOutput.Type;
+
+// The operation
+/**
+ * Get workspace
+ *
+ * Returns the workspace with the given ID.
+ */
+export const getV1WorkspacesById = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetV1WorkspacesByIdInput,
+  outputSchema: GetV1WorkspacesByIdOutput,
+}));