@suss/packs 0.11.0

package/dist/react.js

@@ -0,0 +1,221 @@
+// ../framework/react/dist/index.js
+var STORY_FILE_PATTERN = /\.stories\.tsx?$/;
+var TEST_FILE_PATTERN = /\.(test|spec)\.tsx?$/;
+function startsWithUppercase(name) {
+  if (name.length === 0) {
+    return false;
+  }
+  const first = name[0];
+  return first >= "A" && first <= "Z";
+}
+var reactComponentExports = (sourceFile, ctx) => {
+  const sf = sourceFile;
+  const tsCtx = ctx;
+  const filePath = tsCtx.getFilePath(sf);
+  if (STORY_FILE_PATTERN.test(filePath) || TEST_FILE_PATTERN.test(filePath)) {
+    return [];
+  }
+  const out = [];
+  for (const { name, func, isDefault } of tsCtx.exportedFunctions(sf)) {
+    if (isDefault) {
+      continue;
+    }
+    if (!startsWithUppercase(name)) {
+      continue;
+    }
+    if (!tsCtx.hasJsxReturn(func)) {
+      continue;
+    }
+    out.push({
+      func,
+      kind: "component",
+      name
+    });
+  }
+  return out;
+};
+var EVENT_HANDLER_INPUT = {
+  type: "positionalParams",
+  params: [{ position: 0, role: "event" }]
+};
+var USE_EFFECT_INPUT = {
+  type: "positionalParams",
+  params: []
+};
+function reactSubUnits(parent, ctx) {
+  const tsCtx = ctx;
+  const parentFunc = parent.func;
+  return [
+    ...synthesizeEventHandlers(parent.name, parentFunc, tsCtx),
+    ...synthesizeUseEffects(parent.name, parentFunc, tsCtx)
+  ];
+}
+function isEventHandlerPropName(name) {
+  if (name.length < 3) {
+    return false;
+  }
+  if (name[0] !== "o" || name[1] !== "n") {
+    return false;
+  }
+  const third = name[2];
+  return third === third.toUpperCase() && third !== third.toLowerCase();
+}
+function synthesizeEventHandlers(componentName, parentFunc, ctx) {
+  const raw = [];
+  for (const attr of ctx.findJsxAttributes(parentFunc)) {
+    if (!isEventHandlerPropName(attr.name)) {
+      continue;
+    }
+    const resolved = ctx.resolveAttributeValueFunction(attr, parentFunc);
+    if (resolved === null) {
+      continue;
+    }
+    raw.push({
+      func: resolved.func,
+      tag: attr.tag,
+      propName: attr.name,
+      localName: resolved.localName
+    });
+  }
+  return disambiguateHandlers(raw, componentName);
+}
+function disambiguateHandlers(raw, componentName) {
+  const anonCounts = /* @__PURE__ */ new Map();
+  for (const m of raw) {
+    if (m.localName !== null) {
+      continue;
+    }
+    const key = `${m.tag}.${m.propName}`;
+    anonCounts.set(key, (anonCounts.get(key) ?? 0) + 1);
+  }
+  const anonSeen = /* @__PURE__ */ new Map();
+  return raw.map((m) => {
+    const name = handlerUnitName(m, componentName, anonCounts, anonSeen);
+    return {
+      func: m.func,
+      kind: "handler",
+      name,
+      inputMapping: EVENT_HANDLER_INPUT,
+      // The element and prop a handler hangs off already shape the
+      // summary name; no reader consumes them as metadata (#462).
+      metadata: {
+        react: {
+          kind: "handler",
+          component: componentName
+        }
+      }
+    };
+  });
+}
+function handlerUnitName(m, componentName, anonCounts, anonSeen) {
+  if (m.localName !== null) {
+    return `${componentName}.${m.localName}`;
+  }
+  const key = `${m.tag}.${m.propName}`;
+  const total = anonCounts.get(key) ?? 1;
+  if (total <= 1) {
+    return `${componentName}.${m.tag}.${m.propName}`;
+  }
+  const idx = anonSeen.get(key) ?? 0;
+  anonSeen.set(key, idx + 1);
+  return `${componentName}.${m.tag}.${m.propName}#${idx}`;
+}
+function synthesizeUseEffects(componentName, parentFunc, ctx) {
+  const out = [];
+  let index = 0;
+  for (const call of ctx.findCallExpressionsByName(parentFunc, "useEffect")) {
+    const body = ctx.getCallArgumentFunction(call, 0);
+    if (body === null) {
+      continue;
+    }
+    const depsArg = ctx.getCallArgument(call, 1);
+    const deps = ctx.readArrayLiteralText(depsArg);
+    out.push({
+      func: body,
+      kind: "handler",
+      name: `${componentName}.effect#${index}`,
+      inputMapping: USE_EFFECT_INPUT,
+      metadata: {
+        react: {
+          kind: "effect",
+          component: componentName,
+          index,
+          // `null` deps means the second argument was absent
+          // (re-runs every render); `[]` means mount-only.
+          deps
+        }
+      }
+    });
+    index += 1;
+  }
+  return out;
+}
+function reactFramework() {
+  return {
+    name: "react",
+    languages: ["typescript", "javascript"],
+    // React doesn't have its own wire protocol: it's a framework
+    // running inside a JS runtime, and its boundaries
+    // (component ↔ DOM, render ↔ handler, etc.) don't cross a
+    // network hop. `"in-process"` is the name for that transport class and
+    // will be shared with future in-process packs (custom hooks,
+    // module-internal cross-unit work). Framework identity stays on
+    // `BoundaryBinding.framework` = "react": that's what
+    // distinguishes React-rendered boundaries from, say, a Preact
+    // pack or an arbitrary TS function-call boundary.
+    protocol: "in-process",
+    discovery: [
+      {
+        kind: "component",
+        match: { type: "namedExport", names: ["default"] },
+        // Empty gate: under the current JSX runtime, a file can export a
+        // component with no explicit `react` import at all. The named-export
+        // walk only looks at default exports, so paying for the dispatch on
+        // every file is better than missing those files.
+        requiresImport: []
+      }
+    ],
+    terminals: [
+      {
+        // A return statement whose value is a JSX element or fragment.
+        // Captures the root element/component name as the render
+        // output's identity.
+        kind: "render",
+        match: { type: "jsxReturn" },
+        extraction: {}
+      },
+      {
+        // `return null` (or anything non-JSX) in a component function
+        // is React's way of rendering nothing. Classify as a `return`
+        // terminal with a null value; the branching infrastructure
+        // picks up the guarding condition.
+        kind: "return",
+        match: { type: "returnStatement" },
+        extraction: {}
+      },
+      {
+        // Components can throw: error boundaries up the tree handle
+        // it. Record the thrown type so cross-boundary checks have a
+        // signal without resolving the specific exception.
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {}
+      }
+    ],
+    inputMapping: {
+      // The first positional parameter is conventionally the props
+      // object. When it's destructured (`function X({user, onDelete}: Props)`)
+      // each name becomes its own Input with role = the prop name;
+      // when not (`function X(props)`), one whole-object Input gets
+      // role "props". See `componentProps` in @suss/extractor.
+      type: "componentProps",
+      paramPosition: 0
+    },
+    subUnits: reactSubUnits,
+    discoverUnits: reactComponentExports
+  };
+}
+var index_default = reactFramework;
+export {
+  index_default as default
+};

package/dist/redis.d.ts

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

package/dist/redis.js

@@ -0,0 +1,93 @@
+// ../framework/redis/dist/index.js
+import { declaredBy, pack, storageCalls } from "@suss/recognize";
+var CLIENT_MODULES = ["ioredis", "redis", "iovalkey"];
+var READ_KEY = { kind: "read", selector: { at: 0 } };
+var WRITE_KEY = { kind: "write", selector: { at: 0 } };
+var READ_KEYS = { kind: "read", selector: { from: 0 } };
+var WRITE_KEYS = { kind: "write", selector: { from: 0 } };
+var READ_FIELD = {
+  kind: "read",
+  selector: { at: 0 },
+  fields: { at: 1 }
+};
+var WRITE_FIELD = {
+  kind: "write",
+  selector: { at: 0 },
+  fields: { at: 1 }
+};
+var COMMANDS = {
+  get: READ_KEY,
+  getdel: WRITE_KEY,
+  mget: READ_KEYS,
+  exists: READ_KEY,
+  ttl: READ_KEY,
+  strlen: READ_KEY,
+  set: WRITE_KEY,
+  setex: WRITE_KEY,
+  setnx: WRITE_KEY,
+  psetex: WRITE_KEY,
+  append: WRITE_KEY,
+  incr: WRITE_KEY,
+  incrby: WRITE_KEY,
+  decr: WRITE_KEY,
+  decrby: WRITE_KEY,
+  del: WRITE_KEYS,
+  unlink: WRITE_KEYS,
+  expire: WRITE_KEY,
+  expireat: WRITE_KEY,
+  persist: WRITE_KEY,
+  rename: WRITE_KEY,
+  hget: READ_FIELD,
+  hmget: READ_FIELD,
+  hgetall: READ_KEY,
+  hexists: READ_FIELD,
+  hset: WRITE_FIELD,
+  hmset: WRITE_FIELD,
+  hsetnx: WRITE_FIELD,
+  hincrby: WRITE_FIELD,
+  hdel: WRITE_FIELD,
+  sadd: WRITE_KEY,
+  srem: WRITE_KEY,
+  smembers: READ_KEY,
+  sismember: READ_KEY,
+  scard: READ_KEY,
+  zadd: WRITE_KEY,
+  zrem: WRITE_KEY,
+  zscore: READ_KEY,
+  zrange: READ_KEY,
+  zrevrange: READ_KEY,
+  zrangebyscore: READ_KEY,
+  zcard: READ_KEY,
+  lpush: WRITE_KEY,
+  rpush: WRITE_KEY,
+  lpop: WRITE_KEY,
+  rpop: WRITE_KEY,
+  lrange: READ_KEY,
+  llen: READ_KEY,
+  lrem: WRITE_KEY
+};
+var NAMESPACE_SEPARATOR = ":";
+function namespaceOf(keys) {
+  const namespaces = new Set(
+    keys.map((key) => key.split(NAMESPACE_SEPARATOR)[0] ?? key)
+  );
+  if (namespaces.size !== 1) {
+    return null;
+  }
+  const [only] = [...namespaces];
+  return only === void 0 || only.includes("{") ? null : only;
+}
+var COMMAND_CALLS = storageCalls({
+  system: "redis",
+  client: declaredBy(...CLIENT_MODULES)
+}).methods(COMMANDS, { ignoringCase: true }).container(namespaceOf).example('redis.get("user_online:42")');
+function redisFramework() {
+  return pack("redis", [COMMAND_CALLS], {
+    languages: ["typescript", "javascript"],
+    recognizedAs: "@suss/framework-redis"
+  });
+}
+var index_default = redisFramework;
+export {
+  index_default as default
+};

package/dist/sqlalchemy.d.ts

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

package/dist/sqlalchemy.js

@@ -0,0 +1,48 @@
+// ../framework/sqlalchemy/dist/index.js
+function sqlalchemyStorage(options) {
+  return [
+    {
+      module: "sqlalchemy.orm",
+      queryTypes: ["Query", "Session"],
+      writes: ["update", "delete", "add", "add_all", "merge", "commit"],
+      storageSystem: options.storageSystem
+    },
+    {
+      module: "sqlalchemy",
+      queryTypes: ["Select", "Update", "Delete", "Insert"],
+      writes: ["update", "delete", "insert", "commit"],
+      // 2.0 style writes `select(User.id).where(...)`, importing the
+      // constructor rather than reaching it through a mapped class, so there
+      // is no project method in between whose return says what it is.
+      queryFunctions: ["select", "insert", "update", "delete"],
+      storageSystem: options.storageSystem
+    }
+  ];
+}
+function sqlalchemyRawSql(options) {
+  return [
+    {
+      module: "sqlalchemy",
+      functions: ["text"],
+      storageSystem: options.storageSystem
+    }
+  ];
+}
+function sqlalchemyFramework(options) {
+  if (typeof options?.storageSystem !== "string") {
+    throw new Error(
+      "it needs `storageSystem`, which database is behind the engine: postgresql, mysql, or sqlite. SQLAlchemy talks to all of them and the connection URL settles which, so the pack cannot."
+    );
+  }
+  return {
+    name: "sqlalchemy",
+    protocol: options.storageSystem,
+    discovery: [],
+    storage: sqlalchemyStorage(options),
+    rawSql: sqlalchemyRawSql(options)
+  };
+}
+var index_default = sqlalchemyFramework;
+export {
+  index_default as default
+};

package/dist/ts-rest.d.ts

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

package/dist/ts-rest.js

@@ -0,0 +1,89 @@
+// ../framework/ts-rest/dist/index.js
+function tsRestFramework() {
+  return {
+    name: "ts-rest",
+    protocol: "http",
+    languages: ["typescript"],
+    discovery: [
+      {
+        kind: "handler",
+        match: {
+          type: "registrationCall",
+          importModule: "@ts-rest/express",
+          importName: "initServer",
+          registrationChain: [".router"]
+        },
+        bindingExtraction: {
+          method: { type: "fromContract" },
+          path: { type: "fromContract" }
+        },
+        // Pre-filter to ts-rest server callers. The `@ts-rest/`
+        // prefix sweeps any of the framework's adapters in one
+        // go (`@ts-rest/express` / `@ts-rest/fastify` /
+        // `@ts-rest/nest` / etc.).
+        requiresImport: ["@ts-rest"]
+      },
+      {
+        kind: "client",
+        match: {
+          type: "clientCall",
+          importModule: "@ts-rest/core",
+          importName: "initClient"
+        },
+        bindingExtraction: {
+          method: { type: "fromClientMethod" },
+          path: { type: "fromClientMethod" }
+        },
+        requiresImport: ["@ts-rest"]
+      }
+    ],
+    terminals: [
+      {
+        // ts-rest handlers return { status: N, body: ... }
+        kind: "response",
+        match: {
+          type: "returnShape",
+          requiredProperties: ["status", "body"]
+        },
+        extraction: {
+          statusCode: { from: "property", name: "status" },
+          body: { from: "property", name: "body" }
+        }
+      },
+      // A consumer of a ts-rest client finishes the way any function
+      // does, by returning or throwing. Without these two it matches
+      // no terminal at all and its summary says nothing.
+      { kind: "return", match: { type: "returnStatement" }, extraction: {} },
+      { kind: "throw", match: { type: "throwExpression" }, extraction: {} }
+    ],
+    contractReading: {
+      discovery: {
+        importModule: "@ts-rest/core",
+        importName: "initContract",
+        registrationChain: [".router"]
+      },
+      responseExtraction: { property: "responses" },
+      methodProperty: "method",
+      pathProperty: "path",
+      paramsExtraction: { property: "pathParams" }
+    },
+    inputMapping: {
+      type: "destructuredObject",
+      knownProperties: {
+        params: "pathParams",
+        body: "requestBody",
+        query: "queryParams",
+        headers: "headers"
+      }
+    },
+    responseSemantics: [
+      { name: "status", access: "property", semantics: { type: "statusCode" } },
+      { name: "body", access: "property", semantics: { type: "body" } },
+      { name: "headers", access: "property", semantics: { type: "headers" } }
+    ]
+  };
+}
+var index_default = tsRestFramework;
+export {
+  index_default as default
+};

package/package.json

@@ -0,0 +1,208 @@
+{
+  "name": "@suss/packs",
+  "version": "0.11.0",
+  "type": "module",
+  "description": "Every pack suss ships, as one package with a subpath per pack.",
+  "keywords": [
+    "suss",
+    "behavioral-summary",
+    "packs"
+  ],
+  "license": "Apache-2.0",
+  "author": "Nimbus Cloud AI LLC",
+  "homepage": "https://github.com/nimbuscloud-ai/suss/tree/main/packages/packs#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nimbuscloud-ai/suss.git",
+    "directory": "packages/packs"
+  },
+  "bugs": {
+    "url": "https://github.com/nimbuscloud-ai/suss/issues"
+  },
+  "exports": {
+    "./activerecord": {
+      "types": "./dist/activerecord.d.ts",
+      "import": "./dist/activerecord.js"
+    },
+    "./apollo": {
+      "types": "./dist/apollo.d.ts",
+      "import": "./dist/apollo.js"
+    },
+    "./apollo-client": {
+      "types": "./dist/apollo-client.d.ts",
+      "import": "./dist/apollo-client.js"
+    },
+    "./aws-dynamodb": {
+      "types": "./dist/aws-dynamodb.d.ts",
+      "import": "./dist/aws-dynamodb.js"
+    },
+    "./aws-eventbridge": {
+      "types": "./dist/aws-eventbridge.d.ts",
+      "import": "./dist/aws-eventbridge.js"
+    },
+    "./aws-lambda": {
+      "types": "./dist/aws-lambda.d.ts",
+      "import": "./dist/aws-lambda.js"
+    },
+    "./aws-s3": {
+      "types": "./dist/aws-s3.d.ts",
+      "import": "./dist/aws-s3.js"
+    },
+    "./aws-sqs": {
+      "types": "./dist/aws-sqs.d.ts",
+      "import": "./dist/aws-sqs.js"
+    },
+    "./axios": {
+      "types": "./dist/axios.d.ts",
+      "import": "./dist/axios.js"
+    },
+    "./cloudflare-workers": {
+      "types": "./dist/cloudflare-workers.d.ts",
+      "import": "./dist/cloudflare-workers.js"
+    },
+    "./drizzle": {
+      "types": "./dist/drizzle.d.ts",
+      "import": "./dist/drizzle.js"
+    },
+    "./express": {
+      "types": "./dist/express.d.ts",
+      "import": "./dist/express.js"
+    },
+    "./fastapi": {
+      "types": "./dist/fastapi.d.ts",
+      "import": "./dist/fastapi.js"
+    },
+    "./fastify": {
+      "types": "./dist/fastify.d.ts",
+      "import": "./dist/fastify.js"
+    },
+    "./fetch": {
+      "types": "./dist/fetch.d.ts",
+      "import": "./dist/fetch.js"
+    },
+    "./flask-restx": {
+      "types": "./dist/flask-restx.d.ts",
+      "import": "./dist/flask-restx.js"
+    },
+    "./gcs": {
+      "types": "./dist/gcs.d.ts",
+      "import": "./dist/gcs.js"
+    },
+    "./graphql-ruby": {
+      "types": "./dist/graphql-ruby.d.ts",
+      "import": "./dist/graphql-ruby.js"
+    },
+    "./hono": {
+      "types": "./dist/hono.d.ts",
+      "import": "./dist/hono.js"
+    },
+    "./mongoose": {
+      "types": "./dist/mongoose.d.ts",
+      "import": "./dist/mongoose.js"
+    },
+    "./nestjs-graphql": {
+      "types": "./dist/nestjs-graphql.d.ts",
+      "import": "./dist/nestjs-graphql.js"
+    },
+    "./nestjs-rest": {
+      "types": "./dist/nestjs-rest.d.ts",
+      "import": "./dist/nestjs-rest.js"
+    },
+    "./nextjs": {
+      "types": "./dist/nextjs.d.ts",
+      "import": "./dist/nextjs.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    },
+    "./prisma": {
+      "types": "./dist/prisma.d.ts",
+      "import": "./dist/prisma.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./react-router": {
+      "types": "./dist/react-router.d.ts",
+      "import": "./dist/react-router.js"
+    },
+    "./redis": {
+      "types": "./dist/redis.d.ts",
+      "import": "./dist/redis.js"
+    },
+    "./sqlalchemy": {
+      "types": "./dist/sqlalchemy.d.ts",
+      "import": "./dist/sqlalchemy.js"
+    },
+    "./ts-rest": {
+      "types": "./dist/ts-rest.d.ts",
+      "import": "./dist/ts-rest.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run --passWithNoTests",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "ts-morph": "^23.0.0"
+  },
+  "dependencies": {
+    "@suss/adapter-python": "0.11.0",
+    "@suss/adapter-ruby": "0.11.0",
+    "@suss/adapter-typescript": "0.11.0",
+    "@suss/behavioral-ir": "0.11.0",
+    "@suss/contract-graphql": "0.11.0",
+    "@suss/extractor": "0.11.0",
+    "@suss/manifest-aws": "0.11.0",
+    "@suss/recognize": "0.11.0",
+    "@suss/sql": "0.11.0"
+  },
+  "devDependencies": {
+    "@suss/client-apollo": "*",
+    "@suss/client-axios": "*",
+    "@suss/client-web": "*",
+    "@suss/framework-activerecord": "*",
+    "@suss/framework-apollo": "*",
+    "@suss/framework-aws-dynamodb": "*",
+    "@suss/framework-aws-eventbridge": "*",
+    "@suss/framework-aws-lambda": "*",
+    "@suss/framework-aws-s3": "*",
+    "@suss/framework-aws-sqs": "*",
+    "@suss/framework-cloudflare-workers": "*",
+    "@suss/framework-drizzle": "*",
+    "@suss/framework-express": "*",
+    "@suss/framework-fastapi": "*",
+    "@suss/framework-fastify": "*",
+    "@suss/framework-flask-restx": "*",
+    "@suss/framework-gcs": "*",
+    "@suss/framework-graphql-ruby": "*",
+    "@suss/framework-hono": "*",
+    "@suss/framework-mongoose": "*",
+    "@suss/framework-nestjs-graphql": "*",
+    "@suss/framework-nestjs-rest": "*",
+    "@suss/framework-nextjs": "*",
+    "@suss/framework-prisma": "*",
+    "@suss/framework-react": "*",
+    "@suss/framework-react-router": "*",
+    "@suss/framework-redis": "*",
+    "@suss/framework-sqlalchemy": "*",
+    "@suss/framework-ts-rest": "*",
+    "@suss/runtime-node": "*",
+    "tsup": "*",
+    "typescript": "*",
+    "vitest": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}