@suss/packs 0.34.0 → 0.34.1

package/dist/activerecord.js

@@ -225,7 +225,25 @@ function activeRecordStorage(options) {
         classNameKeyword: "class_name"
       },
       scopes: ["scope"],
-      storageSystem: options.storageSystem
+      storageSystem: options.storageSystem,
+      raises: [
+        {
+          exception: "ActiveRecord::RecordNotFound",
+          methods: [
+            "find",
+            "find_by!",
+            "find_sole_by",
+            "sole",
+            "first!",
+            "last!",
+            "take!"
+          ]
+        },
+        {
+          exception: "ActiveRecord::RecordInvalid",
+          methods: ["save!", "create!", "update!", "find_or_create_by!"]
+        }
+      ]
     }
   ];
 }

package/dist/aiohttp.js

@@ -1,32 +1,43 @@
 // ../client/aiohttp/dist/index.js
-var VERB_METHODS = {
+var VERB_METHODS_THAT_FOLLOW = {
   get: "GET",
   post: "POST",
   put: "PUT",
   patch: "PATCH",
   delete: "DELETE",
-  head: "HEAD",
   options: "OPTIONS"
 };
+function verbCalls(verbs, redirectDelivery) {
+  return {
+    type: "clientCall",
+    importModule: ["aiohttp"],
+    verbAttributeNames: verbs,
+    url: { position: 0, keyword: "url" },
+    receiverConstructors: ["ClientSession"],
+    response: {
+      redirectDelivery,
+      redirectOption: { name: "allow_redirects", handsBack: [false] }
+    }
+  };
+}
 function aiohttpClient() {
   return {
     name: "aiohttp",
     protocol: "http",
     discovery: [],
+    // `head` defaults `allow_redirects` to False, and every other call,
+    // `request("HEAD", url)` included, defaults it to True.
     clients: [
       {
-        type: "clientCall",
-        importModule: ["aiohttp"],
-        verbAttributeNames: VERB_METHODS,
-        url: { position: 0, keyword: "url" },
+        ...verbCalls(VERB_METHODS_THAT_FOLLOW, "followed"),
         methodCall: {
           attribute: "request",
           methodPosition: 0,
           methodKeyword: "method",
           urlPosition: 1
-        },
-        receiverConstructors: ["ClientSession"]
-      }
+        }
+      },
+      verbCalls({ head: "HEAD" }, "response")
     ],
     // `ClientSession.__aenter__` returns the session, so `async with
     // aiohttp.ClientSession() as s` puts the constructed session in s.

package/dist/axios.js

@@ -23,7 +23,21 @@ var optionsSchema = z.object({
    */
   factories: z.array(clientFactory).optional()
 }).strict();
+var CONFIG_POSITION = {
+  get: 1,
+  delete: 1,
+  head: 1,
+  options: 1,
+  post: 2,
+  put: 2,
+  patch: 2
+};
 function discoveryForVerb(verb, factories) {
+  const bindingExtraction = {
+    method: { type: "literal", value: verb.toUpperCase() },
+    path: { type: "fromArgument", position: 0 },
+    options: { position: CONFIG_POSITION[verb] }
+  };
   const patterns = [
     {
       // Matches `axios.<verb>(path)` and `api.<verb>(path)`. factoryMethods
@@ -38,10 +52,7 @@ function discoveryForVerb(verb, factories) {
         factoryMethods: ["create"],
         basePathOption: "baseURL"
       },
-      bindingExtraction: {
-        method: { type: "literal", value: verb.toUpperCase() },
-        path: { type: "fromArgument", position: 0 }
-      },
+      bindingExtraction,
       requiresImport: ["axios"]
     }
   ];
@@ -55,10 +66,7 @@ function discoveryForVerb(verb, factories) {
         methodFilter: [verb],
         basePathOption: "baseURL"
       },
-      bindingExtraction: {
-        method: { type: "literal", value: verb.toUpperCase() },
-        path: { type: "fromArgument", position: 0 }
-      },
+      bindingExtraction,
       // Each importing file spells a relative path differently, so the
       // import-text prefilter cannot match one and a path-shaped factory
       // walks every file. The README has the details.
@@ -78,7 +86,8 @@ function configCallDiscovery(factories) {
       property: "method",
       default: "GET"
     },
-    path: { type: "fromArgumentProperty", position: 0, property: "url" }
+    path: { type: "fromArgumentProperty", position: 0, property: "url" },
+    options: { position: 0 }
   };
   const patterns = [
     {
@@ -146,7 +155,11 @@ function axiosPack(options = {}) {
     ],
     // axios rejects on a non-2xx status, so every failure reaches the
     // caller's catch block instead of coming back as a response.
-    failureDelivery: "exception"
+    failureDelivery: "exception",
+    // axios follows redirects unless the call or the instance sets
+    // `maxRedirects: 0`.
+    redirectDelivery: "followed",
+    redirectOption: { name: "maxRedirects", handsBack: [0] }
   };
 }
 var declares = {

package/dist/faraday.js

@@ -28,7 +28,10 @@ function faradayClient() {
           statusCode: ["status"],
           success: ["success?"],
           body: ["body"],
-          failureDelivery: "response"
+          failureDelivery: "response",
+          // Faraday follows a redirect only with the follow_redirects
+          // middleware added, so a plain connection hands the 3xx back.
+          redirectDelivery: "response"
         }
       }
     ]

package/dist/fastapi.js

@@ -1,5 +1,83 @@
 // ../framework/fastapi/dist/index.js
 import { z } from "zod";
+var STARLETTE_STATUS = {
+  HTTP_100_CONTINUE: 100,
+  HTTP_101_SWITCHING_PROTOCOLS: 101,
+  HTTP_102_PROCESSING: 102,
+  HTTP_103_EARLY_HINTS: 103,
+  HTTP_200_OK: 200,
+  HTTP_201_CREATED: 201,
+  HTTP_202_ACCEPTED: 202,
+  HTTP_203_NON_AUTHORITATIVE_INFORMATION: 203,
+  HTTP_204_NO_CONTENT: 204,
+  HTTP_205_RESET_CONTENT: 205,
+  HTTP_206_PARTIAL_CONTENT: 206,
+  HTTP_207_MULTI_STATUS: 207,
+  HTTP_208_ALREADY_REPORTED: 208,
+  HTTP_226_IM_USED: 226,
+  HTTP_300_MULTIPLE_CHOICES: 300,
+  HTTP_301_MOVED_PERMANENTLY: 301,
+  HTTP_302_FOUND: 302,
+  HTTP_303_SEE_OTHER: 303,
+  HTTP_304_NOT_MODIFIED: 304,
+  HTTP_305_USE_PROXY: 305,
+  HTTP_306_RESERVED: 306,
+  HTTP_307_TEMPORARY_REDIRECT: 307,
+  HTTP_308_PERMANENT_REDIRECT: 308,
+  HTTP_400_BAD_REQUEST: 400,
+  HTTP_401_UNAUTHORIZED: 401,
+  HTTP_402_PAYMENT_REQUIRED: 402,
+  HTTP_403_FORBIDDEN: 403,
+  HTTP_404_NOT_FOUND: 404,
+  HTTP_405_METHOD_NOT_ALLOWED: 405,
+  HTTP_406_NOT_ACCEPTABLE: 406,
+  HTTP_407_PROXY_AUTHENTICATION_REQUIRED: 407,
+  HTTP_408_REQUEST_TIMEOUT: 408,
+  HTTP_409_CONFLICT: 409,
+  HTTP_410_GONE: 410,
+  HTTP_411_LENGTH_REQUIRED: 411,
+  HTTP_412_PRECONDITION_FAILED: 412,
+  HTTP_413_REQUEST_ENTITY_TOO_LARGE: 413,
+  HTTP_413_CONTENT_TOO_LARGE: 413,
+  HTTP_414_REQUEST_URI_TOO_LONG: 414,
+  HTTP_414_URI_TOO_LONG: 414,
+  HTTP_415_UNSUPPORTED_MEDIA_TYPE: 415,
+  HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE: 416,
+  HTTP_416_RANGE_NOT_SATISFIABLE: 416,
+  HTTP_417_EXPECTATION_FAILED: 417,
+  HTTP_418_IM_A_TEAPOT: 418,
+  HTTP_421_MISDIRECTED_REQUEST: 421,
+  HTTP_422_UNPROCESSABLE_ENTITY: 422,
+  HTTP_422_UNPROCESSABLE_CONTENT: 422,
+  HTTP_423_LOCKED: 423,
+  HTTP_424_FAILED_DEPENDENCY: 424,
+  HTTP_425_TOO_EARLY: 425,
+  HTTP_426_UPGRADE_REQUIRED: 426,
+  HTTP_428_PRECONDITION_REQUIRED: 428,
+  HTTP_429_TOO_MANY_REQUESTS: 429,
+  HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  HTTP_500_INTERNAL_SERVER_ERROR: 500,
+  HTTP_501_NOT_IMPLEMENTED: 501,
+  HTTP_502_BAD_GATEWAY: 502,
+  HTTP_503_SERVICE_UNAVAILABLE: 503,
+  HTTP_504_GATEWAY_TIMEOUT: 504,
+  HTTP_505_HTTP_VERSION_NOT_SUPPORTED: 505,
+  HTTP_506_VARIANT_ALSO_NEGOTIATES: 506,
+  HTTP_507_INSUFFICIENT_STORAGE: 507,
+  HTTP_508_LOOP_DETECTED: 508,
+  HTTP_510_NOT_EXTENDED: 510,
+  HTTP_511_NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+var STATUS_MODULES = ["fastapi.status", "starlette.status"];
+var STATUS_CONSTANTS = Object.fromEntries(
+  STATUS_MODULES.flatMap(
+    (module) => Object.entries(STARLETTE_STATUS).map(([name, status]) => [
+      `${module}.${name}`,
+      status
+    ])
+  )
+);
 var optionsSchema = z.object({
   /**
    * Modules that re-export FastAPI's constructors, on top of `fastapi`
@@ -31,6 +109,23 @@ var REQUEST_SPELLING = {
   params: { path: ["pathParams"], saysWhichField: true },
   body: { path: ["requestBody"], saysWhichField: true }
 };
+var INJECTED_PARAMETER_TYPES = [
+  "fastapi.Request",
+  "fastapi.Response",
+  "fastapi.BackgroundTasks",
+  "fastapi.WebSocket",
+  "fastapi.requests.Request",
+  "fastapi.requests.HTTPConnection",
+  "fastapi.responses.Response",
+  "fastapi.background.BackgroundTasks",
+  "fastapi.websockets.WebSocket",
+  "fastapi.security.SecurityScopes",
+  "starlette.requests.Request",
+  "starlette.requests.HTTPConnection",
+  "starlette.responses.Response",
+  "starlette.background.BackgroundTasks",
+  "starlette.websockets.WebSocket"
+];
 function fastapiFramework(options = {}) {
   return {
     name: "fastapi",
@@ -47,12 +142,19 @@ function fastapiFramework(options = {}) {
         // FastAPI resolves both of these itself and calls the handler with
         // the result, so a parameter defaulted to one is never sent.
         injectedParameterCallees: ["Depends", "Security"],
+        // FastAPI also hands a route these objects by the annotation alone.
+        injectedParameterTypes: INJECTED_PARAMETER_TYPES,
         parameterSources: PARAMETER_SOURCES,
         parameterAliasKeyword: "alias",
         // FastAPI returns 200 for a route that declares no status.
         defaultStatusCode: 200,
+        // FastAPI checks every declared request input before the handler
+        // runs, and responds to a bad one itself.
+        validationFailureStatus: 422,
+        statusCodeConstants: STATUS_CONSTANTS,
         responseModelKeyword: "response_model",
         statusCodeKeyword: "status_code",
+        responsesKeyword: "responses",
         // FastAPI re-exports Starlette's class, and a project may import
         // it from either module.
         responseStatusCalls: [

package/dist/fetch.js

@@ -19,7 +19,8 @@ function webFetchPack() {
             property: "method",
             default: "GET"
           },
-          path: { type: "fromArgument", position: 0 }
+          path: { type: "fromArgument", position: 0 },
+          options: { position: 1 }
         },
         // `fetch` is a global, so there is no import to gate on. Walking
         // every file stays cheap because discovery only looks for calls
@@ -54,7 +55,12 @@ function webFetchPack() {
       { name: "text", access: "method", semantics: { type: "body" } },
       { name: "body", access: "property", semantics: { type: "body" } },
       { name: "headers", access: "property", semantics: { type: "headers" } }
-    ]
+    ],
+    // fetch follows 301, 302, 303, 307 and 308, so the caller sees the
+    // final response, unless the call passes `redirect: "manual"` or
+    // `redirect: "error"`.
+    redirectDelivery: "followed",
+    redirectOption: { name: "redirect", handsBack: ["manual", "error"] }
   };
 }
 var declares = {
@@ -62,6 +68,7 @@ var declares = {
   package: "@suss/client-web",
   dependencies: [],
   shippedWith: "typescript",
+  sourcePattern: /(?:^|[^.\w$]|\b(?:window|globalThis|self)\.)fetch\s*\(/m,
   reads: "Global `fetch` call sites."
 };
 var index_default = webFetchPack;

package/dist/httpx.js

@@ -32,7 +32,11 @@ function httpxClient() {
           statusCode: ["status_code"],
           success: ["is_success"],
           body: ["json", "text", "content"],
-          failureDelivery: "response"
+          failureDelivery: "response",
+          // httpx hands a 3xx back unless the call passes
+          // `follow_redirects=True`.
+          redirectDelivery: "response",
+          redirectOption: { name: "follow_redirects", handsBack: [false] }
         }
       }
     ],

package/dist/nestjs-rest.js

@@ -1,5 +1,68 @@
 // ../framework/nestjs-rest/dist/index.js
 import { z } from "zod";
+var HTTP_STATUS = {
+  CONTINUE: 100,
+  SWITCHING_PROTOCOLS: 101,
+  PROCESSING: 102,
+  EARLYHINTS: 103,
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MULTI_STATUS: 207,
+  ALREADY_REPORTED: 208,
+  CONTENT_DIFFERENT: 210,
+  AMBIGUOUS: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  REQUESTED_RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  I_AM_A_TEAPOT: 418,
+  MISDIRECTED: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  UNRECOVERABLE_ERROR: 456,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508
+};
+var HTTP_STATUS_CONSTANTS = Object.fromEntries(
+  Object.entries(HTTP_STATUS).map(([member, status]) => [
+    `HttpStatus.${member}`,
+    status
+  ])
+);
 var optionsSchema = z.object({
   /**
    * Class decorators that wrap `@Controller()` in a package outside the
@@ -9,6 +72,11 @@ var optionsSchema = z.object({
    */
   classDecorators: z.array(z.string()).optional()
 }).strict();
+var NEST_APPLICATION = {
+  importModule: "@nestjs/core",
+  importName: "NestFactory",
+  factory: "create"
+};
 var REQUEST_METHODS = {
   0: "GET",
   1: "POST",
@@ -19,6 +87,57 @@ var REQUEST_METHODS = {
   6: "OPTIONS",
   7: "HEAD"
 };
+var NEST_EXCEPTION_STATUSES = {
+  BadRequestException: 400,
+  UnauthorizedException: 401,
+  ForbiddenException: 403,
+  NotFoundException: 404,
+  MethodNotAllowedException: 405,
+  NotAcceptableException: 406,
+  RequestTimeoutException: 408,
+  ConflictException: 409,
+  GoneException: 410,
+  PreconditionFailedException: 412,
+  PayloadTooLargeException: 413,
+  UnsupportedMediaTypeException: 415,
+  ImATeapotException: 418,
+  MisdirectedException: 421,
+  UnprocessableEntityException: 422,
+  InternalServerErrorException: 500,
+  NotImplementedException: 501,
+  BadGatewayException: 502,
+  ServiceUnavailableException: 503,
+  GatewayTimeoutException: 504,
+  HttpVersionNotSupportedException: 505
+};
+var SWAGGER_RESPONSE_DECORATORS = {
+  ApiResponse: null,
+  ApiOkResponse: 200,
+  ApiCreatedResponse: 201,
+  ApiAcceptedResponse: 202,
+  ApiNoContentResponse: 204,
+  ApiMovedPermanentlyResponse: 301,
+  ApiFoundResponse: 302,
+  ApiBadRequestResponse: 400,
+  ApiUnauthorizedResponse: 401,
+  ApiForbiddenResponse: 403,
+  ApiNotFoundResponse: 404,
+  ApiMethodNotAllowedResponse: 405,
+  ApiNotAcceptableResponse: 406,
+  ApiRequestTimeoutResponse: 408,
+  ApiConflictResponse: 409,
+  ApiGoneResponse: 410,
+  ApiPreconditionFailedResponse: 412,
+  ApiPayloadTooLargeResponse: 413,
+  ApiUnsupportedMediaTypeResponse: 415,
+  ApiUnprocessableEntityResponse: 422,
+  ApiTooManyRequestsResponse: 429,
+  ApiInternalServerErrorResponse: 500,
+  ApiNotImplementedResponse: 501,
+  ApiBadGatewayResponse: 502,
+  ApiServiceUnavailableResponse: 503,
+  ApiGatewayTimeoutResponse: 504
+};
 function nestjsRestFramework(options = {}) {
   return {
     name: "nestjs-rest",
@@ -47,13 +166,10 @@ function nestjsRestFramework(options = {}) {
           // `@HttpCode(n)` sets the status for one handler.
           defaultStatusCodes: { Post: 201 },
           statusCodeDecorator: "HttpCode",
+          statusCodeConstants: HTTP_STATUS_CONSTANTS,
           globalPrefix: {
             method: "setGlobalPrefix",
-            application: {
-              importModule: "@nestjs/core",
-              importName: "NestFactory",
-              factory: "create"
-            },
+            application: NEST_APPLICATION,
             // An exclusion is a path, or a `RouteInfo` whose method is a
             // member of Nest's `RequestMethod` enum.
             exclude: {
@@ -62,6 +178,37 @@ function nestjsRestFramework(options = {}) {
               methodKey: "method",
               methods: REQUEST_METHODS
             }
+          },
+          // A spec `@nestjs/swagger` generates declares these statuses
+          // because of the decorators, whether or not a path sends them.
+          declaredStatuses: {
+            importModule: "@nestjs/swagger",
+            decorators: SWAGGER_RESPONSE_DECORATORS,
+            statusKey: "status"
+          },
+          // `app.enableVersioning()` with no options is URI versioning,
+          // which serves version 1 of a route at `/v1/...`.
+          versioning: {
+            option: "version",
+            decorator: "Version",
+            neutral: "VERSION_NEUTRAL",
+            call: { method: "enableVersioning", application: NEST_APPLICATION },
+            typeKey: "type",
+            types: {
+              "VersioningType.URI": "path",
+              "VersioningType.HEADER": "outsidePath",
+              "VersioningType.MEDIA_TYPE": "outsidePath",
+              "VersioningType.CUSTOM": "outsidePath"
+            },
+            typeNumbers: {
+              0: "path",
+              1: "outsidePath",
+              2: "outsidePath",
+              3: "outsidePath"
+            },
+            defaultType: "path",
+            pathPrefix: { key: "prefix", default: "v" },
+            defaultVersionKey: "defaultVersion"
           }
         },
         requiresImport: ["@nestjs/common"]
@@ -78,12 +225,15 @@ function nestjsRestFramework(options = {}) {
         }
       },
       {
-        // `throw new BadRequestException()`: NestJS turns the exception
-        // into a response. The throw records the exception type, and the
-        // contract check pairs it with the status NestJS would send.
+        // `throw new BadRequestException()`: NestJS's exception filter
+        // sends the status that class is for. Any other throw keeps no
+        // status and stays a throw.
         kind: "throw",
         match: { type: "throwExpression" },
-        extraction: {}
+        extraction: {
+          statusCode: { from: "constructor", codes: NEST_EXCEPTION_STATUSES }
+        },
+        producesResponse: true
       },
       {
         // A method that runs off the end returns undefined, and Nest

package/dist/net-http.js

@@ -43,7 +43,9 @@ function netHttpClient() {
         response: {
           statusCode: ["code"],
           body: ["body"],
-          failureDelivery: "response"
+          failureDelivery: "response",
+          // Net::HTTP never follows a redirect.
+          redirectDelivery: "response"
         }
       }
     ]
@@ -54,6 +56,7 @@ var declares = {
   package: "@suss/client-net-http",
   dependencies: [],
   shippedWith: "ruby",
+  sourcePattern: /\bNet::HTTP\b/,
   reads: "Net::HTTP call sites (Ruby): the module methods that send on their own, and a request object built with `Net::HTTP::Get` and its siblings, with the URL read through `URI`."
 };
 var index_default = netHttpClient;