@suss/packs 0.11.0

package/dist/mongoose.js

@@ -0,0 +1,379 @@
+// ../framework/mongoose/dist/index.js
+import {
+  Node as N
+} from "ts-morph";
+import { methodDeclaredIn } from "@suss/adapter-typescript";
+import { storageBinding } from "@suss/behavioral-ir";
+var RECOGNITION = "@suss/framework-mongoose";
+var STORAGE_SYSTEM = "mongodb";
+var METHODS = {
+  find: { kind: "read", filterArg: 0, projectionArg: 1 },
+  findOne: { kind: "read", filterArg: 0, projectionArg: 1 },
+  findById: { kind: "read", idArg: 0, projectionArg: 1 },
+  countDocuments: { kind: "read", filterArg: 0 },
+  exists: { kind: "read", filterArg: 0 },
+  distinct: { kind: "read", fieldArg: 0, filterArg: 1 },
+  create: { kind: "write", payloadArg: 0 },
+  insertMany: { kind: "write", payloadArg: 0 },
+  updateOne: { kind: "write", filterArg: 0, updateArg: 1 },
+  updateMany: { kind: "write", filterArg: 0, updateArg: 1 },
+  replaceOne: { kind: "write", filterArg: 0, payloadArg: 1 },
+  deleteOne: { kind: "write", filterArg: 0 },
+  deleteMany: { kind: "write", filterArg: 0 },
+  findOneAndUpdate: { kind: "write", filterArg: 0, updateArg: 1 },
+  findByIdAndUpdate: { kind: "write", idArg: 0, updateArg: 1 },
+  findOneAndDelete: { kind: "write", filterArg: 0 },
+  findByIdAndDelete: { kind: "write", idArg: 0 },
+  findOneAndReplace: { kind: "write", filterArg: 0, payloadArg: 1 }
+};
+function defaultCollectionName(modelName) {
+  const lower = modelName.toLowerCase();
+  if (/[^aeiou]y$/.test(lower)) {
+    return `${lower.slice(0, -1)}ies`;
+  }
+  if (/(s|x|z|ch|sh)$/.test(lower)) {
+    return `${lower}es`;
+  }
+  return `${lower}s`;
+}
+function resolveModelIdentity(node, resolve) {
+  if (N.isCallExpression(node)) {
+    return modelIdentityFromModelCall(node, resolve);
+  }
+  if (!N.isIdentifier(node)) {
+    return null;
+  }
+  const symbol = node.getSymbol();
+  if (symbol === void 0) {
+    return null;
+  }
+  for (const decl of symbol.getDeclarations()) {
+    const identity = modelIdentityFromDeclaration(decl, resolve);
+    if (identity !== null) {
+      return identity;
+    }
+  }
+  return null;
+}
+function modelIdentityFromDeclaration(decl, resolve) {
+  if (N.isImportSpecifier(decl)) {
+    const symbol = decl.getNameNode().getSymbol();
+    for (const target of symbol?.getAliasedSymbol()?.getDeclarations() ?? []) {
+      const identity = modelIdentityFromDeclaration(target, resolve);
+      if (identity !== null) {
+        return identity;
+      }
+    }
+    return null;
+  }
+  if (!N.isVariableDeclaration(decl)) {
+    return null;
+  }
+  const init = decl.getInitializer();
+  if (init === void 0 || !N.isCallExpression(init)) {
+    return null;
+  }
+  return modelIdentityFromModelCall(init, resolve);
+}
+function modelIdentityFromModelCall(call, resolve) {
+  const callee = call.getExpression();
+  if (!isModelFactoryCall(callee, resolve)) {
+    return null;
+  }
+  const args = call.getArguments();
+  const modelName = literalString(args[0]);
+  if (modelName === null) {
+    return null;
+  }
+  const explicitCollection = literalString(args[2]);
+  const schemaCollection = explicitCollection === null ? collectionFromSchemaArg(args[1]) : null;
+  const collection = explicitCollection ?? schemaCollection ?? defaultCollectionName(modelName);
+  return { modelName, collection };
+}
+function isModelFactoryCall(callee, resolve) {
+  if (N.isPropertyAccessExpression(callee)) {
+    return callee.getName() === "model" && methodDeclaredIn(callee, "mongoose", resolve);
+  }
+  return N.isIdentifier(callee) && isImportedAs(callee, "mongoose", "model");
+}
+function isImportedAs(identifier, module, exportName) {
+  const symbol = identifier.getSymbol();
+  if (symbol === void 0) {
+    return false;
+  }
+  for (const decl of symbol.getDeclarations()) {
+    if (N.isImportSpecifier(decl) && decl.getName() === exportName && decl.getImportDeclaration().getModuleSpecifierValue() === module) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectionFromSchemaArg(schemaArg) {
+  if (schemaArg === void 0) {
+    return null;
+  }
+  const ctor = schemaConstructorOf(schemaArg);
+  const optionsArg = ctor?.getArguments()[1];
+  if (optionsArg === void 0 || !N.isObjectLiteralExpression(optionsArg)) {
+    return null;
+  }
+  for (const prop of optionsArg.getProperties()) {
+    if (N.isPropertyAssignment(prop) && prop.getName() === "collection") {
+      return literalString(prop.getInitializer());
+    }
+  }
+  return null;
+}
+function schemaConstructorOf(node) {
+  if (N.isNewExpression(node)) {
+    return node;
+  }
+  if (!N.isIdentifier(node)) {
+    return null;
+  }
+  const symbol = node.getSymbol();
+  for (const decl of symbol?.getDeclarations() ?? []) {
+    if (!N.isVariableDeclaration(decl)) {
+      continue;
+    }
+    const init = decl.getInitializer();
+    if (init !== void 0 && N.isNewExpression(init)) {
+      return init;
+    }
+  }
+  return null;
+}
+function resolveDocumentModelIdentity(node, resolve) {
+  if (N.isNewExpression(node)) {
+    return resolveModelIdentity(node.getExpression(), resolve);
+  }
+  if (N.isAwaitExpression(node) || N.isParenthesizedExpression(node)) {
+    return resolveDocumentModelIdentity(node.getExpression(), resolve);
+  }
+  if (N.isCallExpression(node)) {
+    const callee = node.getExpression();
+    if (!N.isPropertyAccessExpression(callee) || !(callee.getName() in METHODS)) {
+      return null;
+    }
+    return resolveModelIdentity(callee.getExpression(), resolve);
+  }
+  if (!N.isIdentifier(node)) {
+    return null;
+  }
+  const symbol = node.getSymbol();
+  for (const decl of symbol?.getDeclarations() ?? []) {
+    if (!N.isVariableDeclaration(decl)) {
+      continue;
+    }
+    const init = decl.getInitializer();
+    const identity = init === void 0 ? null : resolveDocumentModelIdentity(init, resolve);
+    if (identity !== null) {
+      return identity;
+    }
+  }
+  return null;
+}
+function literalString(node) {
+  if (node === void 0) {
+    return null;
+  }
+  return N.isStringLiteral(node) || N.isNoSubstitutionTemplateLiteral(node) ? node.getLiteralValue() : null;
+}
+function readObjectArg(arg) {
+  if (arg === null || arg === void 0 || typeof arg !== "object") {
+    return null;
+  }
+  return arg.kind === "object" ? arg : null;
+}
+function isTruthyLiteral(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (value.kind === "number") {
+    return value.value !== 0;
+  }
+  return value.kind === "boolean" && value.value;
+}
+function projectionFromString(text) {
+  const included = text.trim().split(/\s+/).filter((term) => term.length > 0 && !term.startsWith("-")).map((term) => term.replace(/^\+/, ""));
+  return included.length > 0 ? included : ["*"];
+}
+function projectionFields(arg) {
+  if (arg !== null && typeof arg === "object" && arg.kind === "string") {
+    return projectionFromString(arg.value);
+  }
+  const object = readObjectArg(arg);
+  if (object === null) {
+    return ["*"];
+  }
+  const included = Object.entries(object.fields).filter(([, value]) => isTruthyLiteral(value)).map(([key]) => key);
+  return included.length > 0 ? included : ["*"];
+}
+function updateFields(arg) {
+  const object = readObjectArg(arg);
+  if (object === null) {
+    return ["*"];
+  }
+  const fields = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(object.fields)) {
+    if (!key.startsWith("$")) {
+      fields.add(key);
+      continue;
+    }
+    const operand = readObjectArg(value);
+    for (const inner of Object.keys(operand?.fields ?? {})) {
+      fields.add(inner);
+    }
+  }
+  return fields.size > 0 ? [...fields] : ["*"];
+}
+function payloadFields(arg) {
+  const object = readObjectArg(arg);
+  if (object !== null) {
+    const keys = Object.keys(object.fields);
+    return keys.length > 0 ? keys : ["*"];
+  }
+  if (arg === null || arg === void 0 || typeof arg !== "object" || arg.kind !== "array") {
+    return ["*"];
+  }
+  const union = /* @__PURE__ */ new Set();
+  for (const item of arg.items) {
+    const row = readObjectArg(item);
+    if (row === null) {
+      return ["*"];
+    }
+    for (const key of Object.keys(row.fields)) {
+      union.add(key);
+    }
+  }
+  return union.size > 0 ? [...union] : ["*"];
+}
+function distinctField(arg) {
+  return arg !== null && typeof arg === "object" && arg.kind === "string" ? [arg.value] : [];
+}
+function fieldsOf(spec, args) {
+  if (spec.projectionArg !== void 0) {
+    return projectionFields(args[spec.projectionArg]);
+  }
+  if (spec.updateArg !== void 0) {
+    return updateFields(args[spec.updateArg]);
+  }
+  if (spec.payloadArg !== void 0) {
+    return payloadFields(args[spec.payloadArg]);
+  }
+  if (spec.fieldArg !== void 0) {
+    return distinctField(args[spec.fieldArg]);
+  }
+  return spec.kind === "write" ? ["*"] : [];
+}
+function selectorOf(spec, args) {
+  if (spec.idArg !== void 0) {
+    return args[spec.idArg] !== void 0 ? ["_id"] : null;
+  }
+  if (spec.filterArg === void 0) {
+    return null;
+  }
+  const object = readObjectArg(args[spec.filterArg]);
+  if (object === null) {
+    return null;
+  }
+  const keys = Object.keys(object.fields);
+  return keys.length > 0 ? keys : null;
+}
+function buildAccess(opts) {
+  return {
+    type: "interaction",
+    binding: storageBinding({
+      recognition: RECOGNITION,
+      storageSystem: STORAGE_SYSTEM,
+      scope: opts.scope,
+      container: opts.collection
+    }),
+    callee: opts.calleeText,
+    interaction: {
+      class: "storage-access",
+      kind: opts.kind,
+      fields: opts.fields,
+      ...opts.selector !== null ? { selector: opts.selector } : {},
+      operation: opts.operation
+    }
+  };
+}
+function makeStaticRecognizer(scope) {
+  return (call, ctx) => {
+    const callNode = call;
+    const recognizerCtx = ctx;
+    const resolve = recognizerCtx.resolveWrittenValue ?? (() => null);
+    const callee = callNode.getExpression();
+    if (!N.isPropertyAccessExpression(callee)) {
+      return null;
+    }
+    const method = callee.getName();
+    const spec = METHODS[method];
+    if (spec === void 0 || !methodDeclaredIn(callee, "mongoose", resolve)) {
+      return null;
+    }
+    const identity = resolveModelIdentity(callee.getExpression(), resolve);
+    const args = recognizerCtx.extractArgs?.() ?? [];
+    return [
+      buildAccess({
+        scope,
+        collection: identity?.collection ?? null,
+        calleeText: callee.getText(),
+        operation: method,
+        kind: spec.kind,
+        fields: fieldsOf(spec, args),
+        selector: selectorOf(spec, args)
+      })
+    ];
+  };
+}
+function makeSaveRecognizer(scope) {
+  return (call, ctx) => {
+    const callNode = call;
+    const recognizerCtx = ctx;
+    const resolve = recognizerCtx.resolveWrittenValue ?? (() => null);
+    const callee = callNode.getExpression();
+    if (!N.isPropertyAccessExpression(callee) || callee.getName() !== "save") {
+      return null;
+    }
+    if (!methodDeclaredIn(callee, "mongoose", resolve)) {
+      return null;
+    }
+    const identity = resolveDocumentModelIdentity(
+      callee.getExpression(),
+      resolve
+    );
+    return [
+      buildAccess({
+        scope,
+        collection: identity?.collection ?? null,
+        calleeText: callee.getText(),
+        operation: "save",
+        kind: "write",
+        fields: ["*"],
+        selector: null
+      })
+    ];
+  };
+}
+function mongooseFramework(options = {}) {
+  const scope = options.scope ?? "default";
+  return {
+    name: "mongoose",
+    protocol: "in-process",
+    languages: ["typescript", "javascript"],
+    discovery: [],
+    terminals: [],
+    inputMapping: { type: "positionalParams", params: [] },
+    requiresImport: ["mongoose"],
+    invocationRecognizers: [
+      makeStaticRecognizer(scope),
+      makeSaveRecognizer(scope)
+    ]
+  };
+}
+var index_default = mongooseFramework;
+export {
+  index_default as default
+};

package/dist/nestjs-graphql.d.ts

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

package/dist/nestjs-graphql.js

@@ -0,0 +1,77 @@
+// ../framework/nestjs-graphql/dist/index.js
+function nestjsGraphqlFramework(options = {}) {
+  return {
+    name: "nestjs-graphql",
+    languages: ["typescript"],
+    // Apollo Server runs underneath via `GraphQLModule.forRoot({...
+    // ApolloDriver })`; the wire transport stays HTTP regardless of
+    // whether the resolver was discovered via decorator or via an
+    // object-literal resolver map.
+    protocol: "http",
+    discovery: [
+      {
+        kind: "resolver",
+        match: {
+          type: "decoratedMethod",
+          importModule: "@nestjs/graphql",
+          // First match wins, so the framework's own decorator is
+          // tried before any wrapper a project names.
+          classDecorators: ["Resolver", ...options.classDecorators ?? []],
+          methodDecorators: [
+            "Query",
+            "Mutation",
+            "ResolveField",
+            "Subscription"
+          ],
+          // The three that settle their own type, each named after the
+          // type it puts its field on. `ResolveField` is deliberately
+          // absent: it is the one that needs the class decorator.
+          methodDecoratorTypeMap: {
+            Query: "Query",
+            Mutation: "Mutation",
+            Subscription: "Subscription"
+          }
+        },
+        requiresImport: ["@nestjs/graphql"]
+      }
+    ],
+    terminals: [
+      // Resolvers return a value; errors propagate as thrown
+      // exceptions (NestJS / Apollo map them to `errors[]` on the
+      // outgoing response). No framework-specific response-call
+      // shape: return + throw cover the observable behaviour.
+      {
+        kind: "return",
+        match: { type: "returnStatement" },
+        extraction: {}
+      },
+      {
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {}
+      },
+      {
+        // Resolver methods can fall through and return `undefined` when the
+        // field is optional and the parent object already has the value. Keep a
+        // default transition so the unit does not come out with no transitions
+        // at all.
+        kind: "return",
+        match: { type: "functionFallthrough" },
+        extraction: {}
+      }
+    ],
+    inputMapping: {
+      type: "decoratedParams",
+      decoratorRoleMap: {
+        Args: "args",
+        Parent: "parent",
+        Context: "context",
+        Info: "info"
+      }
+    }
+  };
+}
+var index_default = nestjsGraphqlFramework;
+export {
+  index_default as default
+};

package/dist/nestjs-rest.d.ts

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

package/dist/nestjs-rest.js

@@ -0,0 +1,89 @@
+// ../framework/nestjs-rest/dist/index.js
+function nestjsRestFramework(options = {}) {
+  return {
+    name: "nestjs-rest",
+    languages: ["typescript"],
+    protocol: "http",
+    discovery: [
+      {
+        kind: "handler",
+        match: {
+          type: "decoratedRoute",
+          importModule: "@nestjs/common",
+          // First match wins, so the framework's own decorator is
+          // tried before any wrapper a project names.
+          classDecorators: ["Controller", ...options.classDecorators ?? []],
+          methodDecoratorRouteMap: {
+            Get: "GET",
+            Post: "POST",
+            Put: "PUT",
+            Delete: "DELETE",
+            Patch: "PATCH",
+            Options: "OPTIONS",
+            Head: "HEAD",
+            All: "*"
+          }
+        },
+        requiresImport: ["@nestjs/common"]
+      }
+    ],
+    terminals: [
+      // NestJS controllers serialise the returned value as the
+      // response body and pick a 200 default unless the method
+      // declares `@HttpCode(N)` (deferred: that decorator is
+      // metadata-only). Match bare returns and treat object literals
+      // / identifiers / awaited calls as 200 responses.
+      {
+        kind: "response",
+        match: { type: "returnStatement", excludeCallReturns: false },
+        extraction: {
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // `throw new HttpException(msg, status)` / `throw new
+        // BadRequestException()` etc. NestJS maps these to HTTP
+        // responses; v0 records the exception type so downstream
+        // contract-checking can pair it with the wire status that
+        // the framework would emit.
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {}
+      },
+      {
+        // Many controllers fall through (return undefined) when the
+        // operation is fire-and-forget (`@HttpCode(204)` for
+        // delete-style). Keep a default transition so
+        // `transitions: []` isn't the surface shape.
+        kind: "response",
+        match: { type: "functionFallthrough" },
+        extraction: {
+          defaultStatusCode: 200
+        }
+      }
+    ],
+    inputMapping: {
+      type: "decoratedParams",
+      decoratorRoleMap: {
+        Body: "requestBody",
+        Param: "pathParams",
+        Query: "queryParams",
+        Headers: "headers",
+        Req: "request",
+        Request: "request",
+        Res: "response",
+        Response: "response",
+        Next: "next",
+        Session: "session",
+        Ip: "ip",
+        HostParam: "host",
+        UploadedFile: "file",
+        UploadedFiles: "files"
+      }
+    }
+  };
+}
+var index_default = nestjsRestFramework;
+export {
+  index_default as default
+};

package/dist/nextjs.d.ts

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

package/dist/nextjs.js

@@ -0,0 +1,154 @@
+// ../framework/nextjs/dist/index.js
+var ROUTE_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+];
+var APP_ROUTES = {
+  type: "fromFilename",
+  root: "app",
+  dropBasenames: ["route", "page"],
+  dynamic: "brackets",
+  dropParenthesized: true
+};
+var PAGES_ROUTES = {
+  type: "fromFilename",
+  root: "pages",
+  dropBasenames: ["index"],
+  dynamic: "brackets"
+};
+var NEXT_SERVER = ["next/server"];
+function nextjsFramework() {
+  return {
+    name: "nextjs",
+    protocol: "http",
+    languages: ["typescript", "javascript"],
+    discovery: [
+      {
+        kind: "handler",
+        match: {
+          type: "fileConvention",
+          filePattern: "**/app/**/route.{ts,tsx,js,jsx,mts,mjs}",
+          exportNames: ROUTE_METHODS
+        },
+        bindingExtraction: {
+          method: { type: "fromExportName" },
+          path: APP_ROUTES
+        }
+      },
+      {
+        kind: "handler",
+        match: {
+          type: "fileConvention",
+          filePattern: "**/pages/api/**/*.{ts,tsx,js,jsx,mts,mjs}",
+          exportNames: ["default"]
+        },
+        bindingExtraction: {
+          // One export serves every method, which is what the wildcard says.
+          // Pairing matches it against whichever method a consumer used.
+          method: { type: "literal", value: "*" },
+          path: PAGES_ROUTES
+        }
+      }
+    ],
+    terminals: [
+      {
+        // NextResponse.json(body, { status })
+        kind: "response",
+        match: {
+          type: "functionCall",
+          functionName: "NextResponse.json",
+          requiresImport: NEXT_SERVER
+        },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          statusCode: { from: "argumentProperty", position: 1, name: "status" },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // Response.json(body, { status }), the platform's own, which a
+        // handler can return without importing anything.
+        kind: "response",
+        match: { type: "functionCall", functionName: "Response.json" },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          statusCode: { from: "argumentProperty", position: 1, name: "status" },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // new Response(body, { status }), which a handler returns for
+        // anything that is not JSON: a redirect, a stream, plain text.
+        kind: "response",
+        match: { type: "functionCall", functionName: "Response" },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          statusCode: { from: "argumentProperty", position: 1, name: "status" },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // NextResponse.redirect(url) sends a 307 unless the caller says
+        // otherwise, and the alternative is written as an init object
+        // this pack does not read yet.
+        kind: "response",
+        match: {
+          type: "functionCall",
+          functionName: "NextResponse.redirect",
+          requiresImport: NEXT_SERVER
+        },
+        extraction: { defaultStatusCode: 307 }
+      },
+      {
+        // A pages handler writes to the response it was handed, the
+        // same shape Express uses.
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["status", "json"]
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 0 },
+          body: { from: "argument", position: 0 }
+        }
+      },
+      {
+        kind: "response",
+        match: {
+          type: "parameterMethodCall",
+          parameterPosition: 1,
+          methodChain: ["json"]
+        },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {}
+      }
+    ],
+    // A route handler takes the request first. The app directory hands
+    // it a context object holding the route parameters; a pages handler
+    // takes the response object there instead.
+    inputMapping: {
+      type: "positionalParams",
+      params: [
+        { position: 0, role: "request" },
+        { position: 1, role: "context" }
+      ]
+    }
+  };
+}
+var index_default = nextjsFramework;
+export {
+  index_default as default
+};