casedev 0.3.0 → 0.4.1

package/src/client.ts

@@ -16,26 +16,36 @@ import * as Errors from './core/error';
 import * as Uploads from './core/uploads';
 import * as API from './resources/index';
 import { APIPromise } from './core/api-promise';
+import { Applications } from './resources/applications/applications';
 import { Compute } from './resources/compute/compute';
+import { Database } from './resources/database/database';
 import { Format } from './resources/format/format';
+import { Legal } from './resources/legal/legal';
 import { Llm, LlmGetConfigResponse } from './resources/llm/llm';
+import { Memory } from './resources/memory/memory';
 import { Ocr } from './resources/ocr/ocr';
+import { Privilege } from './resources/privilege/privilege';
 import { Search } from './resources/search/search';
+import { Superdoc } from './resources/superdoc/superdoc';
+import { Translate } from './resources/translate/translate';
 import {
   Vault,
   VaultCreateParams,
   VaultCreateResponse,
+  VaultDeleteParams,
+  VaultDeleteResponse,
   VaultIngestParams,
   VaultIngestResponse,
   VaultListResponse,
   VaultRetrieveResponse,
   VaultSearchParams,
   VaultSearchResponse,
+  VaultUpdateParams,
+  VaultUpdateResponse,
   VaultUploadParams,
   VaultUploadResponse,
 } from './resources/vault/vault';
 import { Voice } from './resources/voice/voice';
-import { Webhooks } from './resources/webhooks/webhooks';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
@@ -532,9 +542,10 @@ export class Casedev {
     controller: AbortController,
   ): Promise<Response> {
     const { signal, method, ...options } = init || {};
-    if (signal) signal.addEventListener('abort', () => controller.abort());
+    const abort = this._makeAbort(controller);
+    if (signal) signal.addEventListener('abort', abort, { once: true });
 
-    const timeout = setTimeout(() => controller.abort(), ms);
+    const timeout = setTimeout(abort, ms);
 
     const isReadableBody =
       ((globalThis as any).ReadableStream && options.body instanceof (globalThis as any).ReadableStream) ||
@@ -557,6 +568,7 @@ export class Casedev {
       return await this.fetch.call(undefined, url, fetchOptions);
     } finally {
       clearTimeout(timeout);
+      if (signal) signal.removeEventListener('abort', abort);
     }
   }
 
@@ -701,6 +713,12 @@ export class Casedev {
     return headers.values;
   }
 
+  private _makeAbort(controller: AbortController) {
+    // note: we can't just inline this method inside `fetchWithTimeout()` because then the closure
+    //       would capture all request options, and cause a memory leak.
+    return () => controller.abort();
+  }
+
   private buildBody({ options: { body, headers: rawHeaders } }: { options: FinalRequestOptions }): {
     bodyHeaders: HeadersLike;
     body: BodyInit | undefined;
@@ -757,53 +775,81 @@ export class Casedev {
 
   static toFile = Uploads.toFile;
 
+  applications: API.Applications = new API.Applications(this);
   compute: API.Compute = new API.Compute(this);
+  database: API.Database = new API.Database(this);
   format: API.Format = new API.Format(this);
+  legal: API.Legal = new API.Legal(this);
   llm: API.Llm = new API.Llm(this);
+  memory: API.Memory = new API.Memory(this);
   ocr: API.Ocr = new API.Ocr(this);
+  privilege: API.Privilege = new API.Privilege(this);
   search: API.Search = new API.Search(this);
+  superdoc: API.Superdoc = new API.Superdoc(this);
+  translate: API.Translate = new API.Translate(this);
   vault: API.Vault = new API.Vault(this);
   voice: API.Voice = new API.Voice(this);
-  webhooks: API.Webhooks = new API.Webhooks(this);
 }
 
+Casedev.Applications = Applications;
 Casedev.Compute = Compute;
+Casedev.Database = Database;
 Casedev.Format = Format;
+Casedev.Legal = Legal;
 Casedev.Llm = Llm;
+Casedev.Memory = Memory;
 Casedev.Ocr = Ocr;
+Casedev.Privilege = Privilege;
 Casedev.Search = Search;
+Casedev.Superdoc = Superdoc;
+Casedev.Translate = Translate;
 Casedev.Vault = Vault;
 Casedev.Voice = Voice;
-Casedev.Webhooks = Webhooks;
 
 export declare namespace Casedev {
   export type RequestOptions = Opts.RequestOptions;
 
+  export { Applications as Applications };
+
   export { Compute as Compute };
 
+  export { Database as Database };
+
   export { Format as Format };
 
+  export { Legal as Legal };
+
   export { Llm as Llm, type LlmGetConfigResponse as LlmGetConfigResponse };
 
+  export { Memory as Memory };
+
   export { Ocr as Ocr };
 
+  export { Privilege as Privilege };
+
   export { Search as Search };
 
+  export { Superdoc as Superdoc };
+
+  export { Translate as Translate };
+
   export {
     Vault as Vault,
     type VaultCreateResponse as VaultCreateResponse,
     type VaultRetrieveResponse as VaultRetrieveResponse,
+    type VaultUpdateResponse as VaultUpdateResponse,
     type VaultListResponse as VaultListResponse,
+    type VaultDeleteResponse as VaultDeleteResponse,
     type VaultIngestResponse as VaultIngestResponse,
     type VaultSearchResponse as VaultSearchResponse,
     type VaultUploadResponse as VaultUploadResponse,
     type VaultCreateParams as VaultCreateParams,
+    type VaultUpdateParams as VaultUpdateParams,
+    type VaultDeleteParams as VaultDeleteParams,
     type VaultIngestParams as VaultIngestParams,
     type VaultSearchParams as VaultSearchParams,
     type VaultUploadParams as VaultUploadParams,
   };
 
   export { Voice as Voice };
-
-  export { Webhooks as Webhooks };
 }

package/src/internal/parse.ts

@@ -29,6 +29,12 @@ export async function defaultParseResponse<T>(client: Casedev, props: APIRespons
     const mediaType = contentType?.split(';')[0]?.trim();
     const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json');
     if (isJSON) {
+      const contentLength = response.headers.get('content-length');
+      if (contentLength === '0') {
+        // if there is no content we can't do anything
+        return undefined as T;
+      }
+
       const json = await response.json();
       return json as T;
     }

package/src/resources/{webhooks/webhooks.ts → applications/applications.ts}

@@ -1,15 +1,15 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../../core/resource';
-import * as V1API from './v1';
-import { V1 } from './v1';
+import * as V1API from './v1/v1';
+import { V1 } from './v1/v1';
 
-export class Webhooks extends APIResource {
+export class Applications extends APIResource {
   v1: V1API.V1 = new V1API.V1(this._client);
 }
 
-Webhooks.V1 = V1;
+Applications.V1 = V1;
 
-export declare namespace Webhooks {
+export declare namespace Applications {
   export { V1 as V1 };
 }

package/src/resources/applications/index.ts

@@ -0,0 +1,4 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Applications } from './applications';
+export { V1 } from './v1/index';

package/src/resources/applications/v1/deployments.ts

@@ -0,0 +1,183 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+export class Deployments extends APIResource {
+  /**
+   * Trigger a new deployment for a project
+   */
+  create(body: DeploymentCreateParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post('/applications/v1/deployments', {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Get details of a specific deployment including build logs
+   */
+  retrieve(id: string, query: DeploymentRetrieveParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/applications/v1/deployments/${id}`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * List deployments for a project
+   */
+  list(query: DeploymentListParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/applications/v1/deployments', {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Cancel a running deployment
+   */
+  cancel(id: string, body: DeploymentCancelParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post(path`/applications/v1/deployments/${id}/cancel`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Create a deployment from raw file contents (for Thurgood sandbox deployments)
+   */
+  createFromFiles(options?: RequestOptions): APIPromise<void> {
+    return this._client.post('/applications/v1/deployments/from-files', {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Get build logs for a specific deployment
+   */
+  getLogs(id: string, query: DeploymentGetLogsParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/applications/v1/deployments/${id}/logs`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Get the current status of a deployment
+   */
+  getStatus(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/applications/v1/deployments/${id}/status`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Stream real-time deployment progress events via Server-Sent Events
+   */
+  stream(id: string, query: DeploymentStreamParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/applications/v1/deployments/${id}/stream`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface DeploymentCreateParams {
+  /**
+   * Project ID
+   */
+  projectId: string;
+
+  /**
+   * Git ref (branch, tag, or commit) to deploy
+   */
+  ref?: string;
+
+  /**
+   * Deployment target
+   */
+  target?: 'production' | 'preview';
+}
+
+export interface DeploymentRetrieveParams {
+  /**
+   * Project ID (for authorization)
+   */
+  projectId: string;
+
+  /**
+   * Include build logs
+   */
+  includeLogs?: boolean;
+}
+
+export interface DeploymentListParams {
+  /**
+   * Project ID
+   */
+  projectId: string;
+
+  /**
+   * Maximum number of deployments to return
+   */
+  limit?: number;
+
+  /**
+   * Filter by deployment state
+   */
+  state?: string;
+
+  /**
+   * Filter by deployment target
+   */
+  target?: 'production' | 'staging';
+}
+
+export interface DeploymentCancelParams {
+  /**
+   * Project ID (for authorization)
+   */
+  projectId: string;
+}
+
+export interface DeploymentGetLogsParams {
+  /**
+   * Project ID (for authorization)
+   */
+  projectId: string;
+}
+
+export interface DeploymentStreamParams {
+  /**
+   * Project ID (for authorization)
+   */
+  projectId: string;
+
+  /**
+   * Resume stream from this index (for reconnection)
+   */
+  startIndex?: number;
+}
+
+export declare namespace Deployments {
+  export {
+    type DeploymentCreateParams as DeploymentCreateParams,
+    type DeploymentRetrieveParams as DeploymentRetrieveParams,
+    type DeploymentListParams as DeploymentListParams,
+    type DeploymentCancelParams as DeploymentCancelParams,
+    type DeploymentGetLogsParams as DeploymentGetLogsParams,
+    type DeploymentStreamParams as DeploymentStreamParams,
+  };
+}

package/src/resources/applications/v1/index.ts

@@ -0,0 +1,27 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Deployments,
+  type DeploymentCreateParams,
+  type DeploymentRetrieveParams,
+  type DeploymentListParams,
+  type DeploymentCancelParams,
+  type DeploymentGetLogsParams,
+  type DeploymentStreamParams,
+} from './deployments';
+export {
+  Projects,
+  type ProjectListResponse,
+  type ProjectCreateParams,
+  type ProjectDeleteParams,
+  type ProjectCreateDeploymentParams,
+  type ProjectCreateDomainParams,
+  type ProjectCreateEnvParams,
+  type ProjectDeleteDomainParams,
+  type ProjectDeleteEnvParams,
+  type ProjectGetRuntimeLogsParams,
+  type ProjectListDeploymentsParams,
+  type ProjectListEnvParams,
+} from './projects';
+export { V1 } from './v1';
+export { Workflows, type WorkflowGetStatusParams } from './workflows';