@suss/packs 0.11.0

package/dist/fetch.js

@@ -0,0 +1,64 @@
+// ../client/web/dist/index.js
+function webFetchPack() {
+  return {
+    name: "fetch",
+    protocol: "http",
+    languages: ["typescript"],
+    discovery: [
+      {
+        kind: "client",
+        match: {
+          type: "clientCall",
+          importModule: "global",
+          importName: "fetch"
+        },
+        bindingExtraction: {
+          method: {
+            type: "fromArgumentProperty",
+            position: 1,
+            property: "method",
+            default: "GET"
+          },
+          path: { type: "fromArgumentLiteral", position: 0 }
+        },
+        // No import gate: `fetch` is a global. Walk every file,
+        // the discovery dispatch is itself cheap (just looks for
+        // call expressions named `fetch`), so the lack of pre-
+        // filter doesn't blow up perf.
+        requiresImport: []
+      }
+    ],
+    terminals: [
+      {
+        kind: "return",
+        match: { type: "returnStatement" },
+        extraction: {}
+      },
+      {
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {}
+      }
+    ],
+    inputMapping: {
+      type: "positionalParams",
+      params: []
+    },
+    responseSemantics: [
+      {
+        name: "ok",
+        access: "property",
+        semantics: { type: "statusRange", min: 200, max: 299 }
+      },
+      { name: "status", access: "property", semantics: { type: "statusCode" } },
+      { name: "json", access: "method", semantics: { type: "body" } },
+      { name: "text", access: "method", semantics: { type: "body" } },
+      { name: "body", access: "property", semantics: { type: "body" } },
+      { name: "headers", access: "property", semantics: { type: "headers" } }
+    ]
+  };
+}
+var index_default = webFetchPack;
+export {
+  index_default as default
+};

package/dist/flask-restx.d.ts

@@ -0,0 +1 @@
+export { default } from '@suss/framework-flask-restx';

package/dist/flask-restx.js

@@ -0,0 +1,59 @@
+// ../framework/flask-restx/dist/index.js
+var VERB_METHOD_NAMES = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  delete: "DELETE",
+  patch: "PATCH",
+  head: "HEAD",
+  options: "OPTIONS"
+};
+function flaskRestxFramework(options = {}) {
+  return {
+    name: "flask-restx",
+    protocol: "http",
+    ...options.wrapperModules !== void 0 ? { projectModules: options.wrapperModules } : {},
+    discovery: [
+      {
+        type: "decoratedClassRoute",
+        importModule: ["flask_restx", ...options.wrapperModules ?? []],
+        decoratorName: "route",
+        verbMethodNames: VERB_METHOD_NAMES,
+        pathParamSyntax: "flaskConverters",
+        // What each of these settings means for a written prefix is the
+        // grid in the Python adapter's README.
+        pathRepeatedSlashes: "merged",
+        routerComposition: {
+          routerConstructorName: "Namespace",
+          includeMethodName: "add_namespace",
+          prefixKeyword: "path",
+          mountPrefixEffect: "replaces",
+          constructorPrefixRequired: true,
+          constructorPrefixTrailingSlash: "trimmed",
+          noValuePrefix: "unstated",
+          mountObjectPrefix: {
+            prefixKeyword: "prefix",
+            carrier: {
+              importModule: ["flask"],
+              constructorName: "Blueprint",
+              argumentIndex: 0,
+              prefixKeyword: "url_prefix",
+              handoffMethodName: "init_app",
+              registerMethodName: "register_blueprint"
+            }
+          }
+        },
+        // Flask returns 200 from a resource method that returns a value
+        // and sets no status of its own.
+        defaultStatusCode: 200,
+        // Flask reads a status out of `return body, 201`, so the 200
+        // above only stands when the body writes no status of its own.
+        statusFromReturnedTuple: true
+      }
+    ]
+  };
+}
+var index_default = flaskRestxFramework;
+export {
+  index_default as default
+};

package/dist/gcs.d.ts

@@ -0,0 +1 @@
+export { default } from '@suss/framework-gcs';

package/dist/gcs.js

@@ -0,0 +1,134 @@
+// ../framework/gcs/dist/index.js
+import { Node as N } from "ts-morph";
+import { methodDeclaredIn, readName } from "@suss/adapter-typescript";
+import { storageBinding } from "@suss/behavioral-ir";
+var RECOGNITION = "@suss/framework-gcs";
+var CLIENT_MODULE = "@google-cloud/storage";
+var OPERATIONS = {
+  download: "read",
+  createReadStream: "read",
+  getMetadata: "read",
+  exists: "read",
+  isPublic: "read",
+  getFiles: "read",
+  save: "write",
+  upload: "write",
+  createWriteStream: "write",
+  delete: "write",
+  copy: "write",
+  move: "write",
+  rename: "write",
+  setMetadata: "write",
+  makePublic: "write",
+  makePrivate: "write"
+};
+var SIGNED_URL = "getSignedUrl";
+var SIGNED_ACTIONS = {
+  read: "read",
+  write: "write",
+  delete: "write",
+  resumable: "write"
+};
+var BUCKET_STEP = "bucket";
+var FILE_STEP = "file";
+function gcsRecognizer(call, ctx) {
+  const callNode = call;
+  const resolve = ctx.resolveWrittenValue ?? (() => null);
+  const callee = callNode.getExpression();
+  if (!N.isPropertyAccessExpression(callee)) {
+    return null;
+  }
+  const operation = callee.getName();
+  const kind = kindOf(operation, callNode, resolve);
+  if (kind === null || !methodDeclaredIn(callee, CLIENT_MODULE)) {
+    return null;
+  }
+  const chain = walkChain(callee.getExpression(), resolve);
+  return [
+    {
+      type: "interaction",
+      binding: storageBinding({
+        recognition: RECOGNITION,
+        storageSystem: "gcs",
+        scope: "default",
+        container: chain.bucket,
+        accessPath: null
+      }),
+      callee: callee.getText(),
+      interaction: {
+        class: "storage-access",
+        kind,
+        // An object has no fields, so a call says nothing about any.
+        fields: [],
+        operation,
+        ...chain.object !== null ? { selector: [chain.object] } : {}
+      }
+    }
+  ];
+}
+function kindOf(operation, call, resolve) {
+  if (operation !== SIGNED_URL) {
+    return OPERATIONS[operation] ?? null;
+  }
+  const config = call.getArguments()[0];
+  const asked = config === void 0 ? null : property(config, "action");
+  const action = asked === null ? null : readName(asked, { resolve });
+  return action === null ? "read" : SIGNED_ACTIONS[action] ?? "read";
+}
+function walkChain(subject, resolve) {
+  let step = subject;
+  const found = { bucket: null, object: null };
+  for (let hops = 0; step !== null && hops < MAX_CHAIN_STEPS; hops++) {
+    if (N.isIdentifier(step) || N.isPropertyAccessExpression(step)) {
+      const written = resolve(step);
+      step = written === step ? null : written;
+      continue;
+    }
+    if (!N.isCallExpression(step)) {
+      return found;
+    }
+    const callee = step.getExpression();
+    if (!N.isPropertyAccessExpression(callee)) {
+      return found;
+    }
+    const named = callee.getName();
+    const argument = step.getArguments()[0];
+    if (named === FILE_STEP && found.object === null) {
+      found.object = argument === void 0 ? null : readName(argument, { resolve, unsettled: "reference" });
+    }
+    if (named === BUCKET_STEP && found.bucket === null) {
+      found.bucket = argument === void 0 ? null : readName(argument, { resolve, unsettled: "reference" });
+      return found;
+    }
+    step = callee.getExpression();
+  }
+  return found;
+}
+var MAX_CHAIN_STEPS = 8;
+function property(input, name) {
+  if (!N.isObjectLiteralExpression(input)) {
+    return null;
+  }
+  for (const prop of input.getProperties()) {
+    if (N.isPropertyAssignment(prop) && prop.getName() === name) {
+      return prop.getInitializer() ?? null;
+    }
+  }
+  return null;
+}
+function gcsFramework() {
+  return {
+    name: "gcs",
+    protocol: "gcs",
+    languages: ["typescript", "javascript"],
+    discovery: [],
+    terminals: [],
+    inputMapping: { type: "positionalParams", params: [] },
+    requiresImport: [CLIENT_MODULE],
+    invocationRecognizers: [gcsRecognizer]
+  };
+}
+var index_default = gcsFramework;
+export {
+  index_default as default
+};

package/dist/graphql-ruby.d.ts

@@ -0,0 +1 @@
+export { default } from '@suss/framework-graphql-ruby';

package/dist/graphql-ruby.js

@@ -0,0 +1,84 @@
+// ../framework/graphql-ruby/dist/index.js
+import path from "path";
+import { SCALAR_SHAPES } from "@suss/contract-graphql";
+var DEFAULT_BASE_CLASS_NAMES = [
+  "Types::BaseObject",
+  "Types::BaseInterface",
+  "Types::BaseInputObject",
+  "Types::BaseEnum",
+  "Types::BaseUnion",
+  "Types::BaseScalar"
+];
+function rootDirectory(options) {
+  if (options.configDirectory === void 0 || path.isAbsolute(options.root)) {
+    return options.root;
+  }
+  return path.resolve(options.configDirectory, options.root);
+}
+function graphqlRubyFramework(options) {
+  if (typeof options?.root !== "string" || options.root === "") {
+    throw new Error(
+      "it needs `root`, the directory a wired field's class is looked up under, and no default can be right: that is this project's own directory layout. A Rails app generated by the library keeps it at app/graphql."
+    );
+  }
+  const pattern = {
+    type: "graphqlObjectFields",
+    baseClassNames: [
+      ...DEFAULT_BASE_CLASS_NAMES,
+      ...options.baseClassNames ?? []
+    ],
+    root: rootDirectory(options),
+    pathConvention: "railsUnderscore",
+    fieldCallName: "field",
+    typeCallName: "type",
+    argumentCallName: "argument",
+    wiringKeywords: ["mutation", "resolver"],
+    resolverMethodName: "resolve",
+    // The classes graphql-ruby's own generated base classes extend or
+    // mix in. A project's chain ends at one of them.
+    ancestryRootClassNames: [
+      "GraphQL::Schema::Object",
+      "GraphQL::Schema::Mutation",
+      "GraphQL::Schema::Resolver",
+      "GraphQL::Schema::Interface",
+      "GraphQL::Schema::InputObject",
+      "GraphQL::Schema::Enum",
+      "GraphQL::Schema::Union",
+      "GraphQL::Schema::Scalar"
+    ],
+    requiredKeyword: "required",
+    // graphql-ruby registers an argument as required unless the call
+    // opts out with `required: false`.
+    requiredDefault: true,
+    camelizeKeyword: "camelize",
+    camelizeDefault: options.camelize ?? true,
+    // The standard scalars come from the shared SDL table, so a
+    // contract read from Ruby compares against one read from SDL
+    // without a vocabulary mismatch. graphql-ruby accepts Ruby's own
+    // `Integer` class as a synonym for its `Int` scalar.
+    scalars: {
+      ...SCALAR_SHAPES,
+      Integer: { type: "number" }
+    },
+    scalarNamePrefixes: ["GraphQL::Types::"],
+    typeNameConvention: "stripTypeSuffix",
+    // RelayClassicMutation wraps every declared argument into one
+    // `input` argument on the wire and adds clientMutationId to it.
+    argumentWrapping: {
+      ancestorClassName: "GraphQL::Schema::RelayClassicMutation",
+      argumentName: "input",
+      extraFields: {
+        clientMutationId: { type: { type: "text" }, required: false }
+      }
+    }
+  };
+  return {
+    name: "graphql-ruby",
+    protocol: "http-graphql",
+    discovery: [pattern]
+  };
+}
+var index_default = graphqlRubyFramework;
+export {
+  index_default as default
+};

package/dist/hono.d.ts

@@ -0,0 +1 @@
+export { default } from '@suss/framework-hono';

package/dist/hono.js

@@ -0,0 +1,184 @@
+// ../framework/hono/dist/index.js
+import { httpRouteDiscovery } from "@suss/extractor";
+var HTTP_EXCEPTION_CODES = {
+  HTTPException: 500
+};
+function honoFramework() {
+  return {
+    name: "hono",
+    protocol: "http",
+    languages: ["typescript", "javascript"],
+    // createRoute wraps its config without changing it; the call IS the
+    // route object. Declared here because the wrapper's body lives in
+    // the library, where nobody can read it.
+    transparentWrappers: [
+      { callee: "createRoute", argument: 0, module: "@hono/zod-openapi" }
+    ],
+    // `new Hono()` and `new OpenAPIHono()` both register the same way.
+    // Sub-apps mounted with `app.route(prefix, sub)` compose the
+    // prefix into a route declared on the sub-app, following the sub-app
+    // through an import when it's declared in another file. A mount
+    // nested more than one level deep composes too, since the same
+    // index a mount resolves to is asked again for its own mount; a
+    // mount the resolution store can't follow to a concrete sub-app,
+    // or whose prefix isn't a string literal, leaves the route's path
+    // as written.
+    discovery: [
+      ...httpRouteDiscovery({
+        importModule: "hono",
+        importNames: ["Hono", "OpenAPIHono"],
+        methods: [
+          ".get",
+          ".post",
+          ".put",
+          ".delete",
+          ".patch",
+          ".options",
+          ".all"
+        ],
+        mount: { method: "route", prefixPosition: 0, targetPosition: 1 }
+      }),
+      ...httpRouteDiscovery({
+        importModule: "@hono/zod-openapi",
+        importNames: ["OpenAPIHono"],
+        methods: [
+          ".get",
+          ".post",
+          ".put",
+          ".delete",
+          ".patch",
+          ".options",
+          ".all"
+        ],
+        mount: { method: "route", prefixPosition: 0, targetPosition: 1 }
+      }),
+      {
+        // app.openapi(route, handler), where the route is a
+        // createRoute({ method, path, ... }) object that usually lives
+        // on a shared contract in another file. The fact layer follows
+        // the reference, and the route object has its own method and path on
+        // it.
+        kind: "handler",
+        match: {
+          type: "registrationCall",
+          importModule: "@hono/zod-openapi",
+          importName: "OpenAPIHono",
+          registrationChain: [".openapi"]
+        },
+        bindingExtraction: {
+          method: {
+            type: "fromArgumentProperty",
+            position: 0,
+            property: "method"
+          },
+          path: { type: "fromArgumentProperty", position: 0, property: "path" }
+        },
+        requiresImport: ["@hono/zod-openapi"]
+      }
+    ],
+    // The createRoute object registered alongside the handler declares
+    // the endpoint's responses, so a handler returning a status the
+    // route never declares is a contract finding, not a style choice.
+    contractReading: {
+      discovery: {
+        importModule: "@hono/zod-openapi",
+        importName: "OpenAPIHono",
+        registrationChain: [".openapi"]
+      },
+      responseExtraction: { property: "responses" },
+      methodProperty: "method",
+      pathProperty: "path",
+      endpoint: { from: "registrationArgument", position: 0 }
+    },
+    terminals: [
+      {
+        // c.json(body, status?)
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 0,
+          methodChain: ["json"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 1 },
+          body: { from: "argument", position: 0 },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // c.text(body, status?)
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 0,
+          methodChain: ["text"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 1 },
+          body: { from: "argument", position: 0 },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // c.body(data, status?)
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 0,
+          methodChain: ["body"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 1 },
+          body: { from: "argument", position: 0 },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // c.redirect(location, status?). Hono defaults to 302.
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 0,
+          methodChain: ["redirect"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 1 },
+          defaultStatusCode: 302
+        }
+      },
+      {
+        // c.notFound()
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 0,
+          methodChain: ["notFound"]
+        },
+        extraction: { defaultStatusCode: 404 }
+      },
+      {
+        // throw new HTTPException(status, { message }); hono sends the
+        // exception's status as the wire response.
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {
+          statusCode: {
+            from: "constructor",
+            codes: HTTP_EXCEPTION_CODES
+          }
+        },
+        producesResponse: true
+      }
+    ],
+    // One parameter, the context, carrying the request and the response
+    // methods together.
+    inputMapping: {
+      type: "positionalParams",
+      params: [{ position: 0, role: "context" }]
+    }
+  };
+}
+var index_default = honoFramework;
+export {
+  index_default as default
+};

package/dist/mongoose.d.ts

@@ -0,0 +1 @@
+export { default } from '@suss/framework-mongoose';