@typeship-ax/cli 0.6.0 → 0.9.1

package/src/resources/generate.ts

@@ -3,67 +3,90 @@
 
 import { HttpCore, type ApiResult, type RequestOptions } from "../core/http.js";
 import {
+  ResponseParseError,
   TransportError,
   UnexpectedApiError,
   ValidationError,
   ApiResponseError,
   BadRequestError,
+  ConflictError,
   ForbiddenError,
   PayloadTooLargeError,
   RateLimitedError,
   UnauthorizedError,
   UnprocessableEntityError,
 } from "../errors.js";
-import type { GenerateRequest, GenerationResult } from "../types.js";
+import type { GenerateRequest, GenerationResult, GenerationResultRead } from "../types.js";
 
 export class GenerateResource {
   constructor(private readonly _core: HttpCore) {}
   /**
-   * Generate a package from a spec
+   * Generate one Target from a Definition
    *
    * Stateless generation: nothing is stored. Returns the full generated
    * package as files. Works without an API key: anonymous calls generate
    * the first 25 operations, rate limited per IP address, and the
    * response's `limits` object says what was held back and where to lift
-   * it; anonymous calls from a spec URL also carry `claim.url`, a link
+   * it; anonymous calls from a Definition URL also carry `claim.url`, a link
    * that turns the run into a project once a person signs in. With a key, the free plan generates
    * the first 25 operations and
-   * paid plans generate the whole spec. A present but invalid key is a
+   * paid plans generate the complete Definition. A present but invalid key is a
    * 401, not a downgrade to anonymous.
+   *
+   * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
    * `POST /generate`
    */
   async run(
     body: GenerateRequest,
+    params?: GenerateRunParams,
     options?: RequestOptions,
-  ): Promise<ApiResult<GenerationResult, GenerateRunError>> {
-    return this._core.request<GenerationResult, GenerateRunError>({
+  ): Promise<ApiResult<GenerationResultRead, GenerateRunError>> {
+    return this._core.request<GenerationResultRead, GenerateRunError>({
       method: "POST",
       path: "/generate",
+      security: [{},{"apiKey":[]}],
+      headers: {
+        "Idempotency-Key": params?.idempotencyKey === undefined ? undefined : String(params?.idempotencyKey),
+      },
       body,
       errors: {
         "400": BadRequestError,
         "401": UnauthorizedError,
         "403": ForbiddenError,
+        "409": ConflictError,
         "413": PayloadTooLargeError,
         "422": UnprocessableEntityError,
         "429": RateLimitedError,
         default: ApiResponseError,
       },
+      idempotencyKey: "Idempotency-Key",
       schemaKey: "generate.run",
       options,
     });
   }
 }
 
+export interface GenerateRunParams {
+  /**
+   * Identifies one logical write for 24 hours. The key is scoped to the authenticated account and
+   * operation; account-less generation uses a hashed network identity. Retrying the same method,
+   * path, query, and JSON body replays the original response. Reusing the key with changed intent
+   * returns 409. After expiry the key starts a new write.
+   */
+  idempotencyKey?: string;
+}
+
 /** Every error `run` can produce, as a discriminated union. */
 export type GenerateRunError =
   | BadRequestError
   | UnauthorizedError
   | ForbiddenError
+  | ConflictError
   | PayloadTooLargeError
   | UnprocessableEntityError
   | RateLimitedError
   | ApiResponseError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;

package/src/resources/generations.ts

@@ -3,6 +3,7 @@
 
 import { HttpCore, type ApiResult, type RequestOptions } from "../core/http.js";
 import {
+  ResponseParseError,
   TransportError,
   UnexpectedApiError,
   ValidationError,
@@ -12,7 +13,7 @@ import {
   RateLimitedError,
   UnauthorizedError,
 } from "../errors.js";
-import type { Generation, GenerationId } from "../types.js";
+import type { GenerationId, GenerationResponse, GenerationResponseRead } from "../types.js";
 
 export class GenerationsResource {
   constructor(private readonly _core: HttpCore) {}
@@ -25,10 +26,11 @@ export class GenerationsResource {
   async retrieve(
     generationId: GenerationId,
     options?: RequestOptions,
-  ): Promise<ApiResult<Generation, GenerationsRetrieveError>> {
-    return this._core.request<Generation, GenerationsRetrieveError>({
+  ): Promise<ApiResult<GenerationResponseRead, GenerationsRetrieveError>> {
+    return this._core.request<GenerationResponseRead, GenerationsRetrieveError>({
       method: "GET",
       path: `/generations/${encodeURIComponent(String(generationId))}`,
+      security: [{"apiKey":[]}],
       errors: {
         "401": UnauthorizedError,
         "403": ForbiddenError,
@@ -44,7 +46,7 @@ export class GenerationsResource {
   /**
    * Fetch one file from a generation
    *
-   * Raw file content, for generations whose output was too large to inline (files_omitted true).
+   * Raw file content, for generations whose target was too large to inline (files_omitted true).
    * The generation's files_index lists valid paths.
    * `GET /generations/{generation_id}/file`
    */
@@ -56,6 +58,7 @@ export class GenerationsResource {
     return this._core.request<string, GenerationsRetrieveFileError>({
       method: "GET",
       path: `/generations/${encodeURIComponent(String(generationId))}/file`,
+      security: [{"apiKey":[]}],
       query: {
         path: params.path,
       },
@@ -80,6 +83,7 @@ export type GenerationsRetrieveError =
   | NotFoundError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
@@ -96,5 +100,6 @@ export type GenerationsRetrieveFileError =
   | NotFoundError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;