@suss/packs 0.11.0

package/dist/prisma.js

@@ -0,0 +1,448 @@
+// ../framework/prisma/dist/index.js
+import {
+  Node as N
+} from "ts-morph";
+import { storageBinding } from "@suss/behavioral-ir";
+import { readSqlAccess, sqlFromParts } from "@suss/sql";
+var RAW_METHODS = /* @__PURE__ */ new Set([
+  "$queryRaw",
+  "$executeRaw",
+  "$queryRawUnsafe",
+  "$executeRawUnsafe"
+]);
+var PRISMA_READ_METHODS = /* @__PURE__ */ new Set([
+  "findUnique",
+  "findFirst",
+  "findMany",
+  "count",
+  "aggregate",
+  "groupBy"
+]);
+var WRITE_PAYLOAD_KEYS = ["data", "create", "update"];
+var PRISMA_WRITE_METHODS = /* @__PURE__ */ new Set([
+  "create",
+  "update",
+  "delete",
+  "upsert",
+  "createMany",
+  "updateMany",
+  "deleteMany"
+]);
+function makeRecognizer(opts) {
+  const storageSystem = opts.storageSystem ?? "postgresql";
+  const scope = opts.scope ?? "default";
+  return (call, ctx) => recognizePrismaCall(call, ctx, storageSystem, scope);
+}
+function recognizePrismaCall(call, ctx, storageSystem, scope) {
+  const callNode = call;
+  const recognizerCtx = ctx;
+  const calleeExpr = callNode.getExpression();
+  if (!N.isPropertyAccessExpression(calleeExpr)) {
+    return null;
+  }
+  const delegateExpr = calleeExpr.getExpression();
+  if (!N.isPropertyAccessExpression(delegateExpr)) {
+    return null;
+  }
+  const method = calleeExpr.getName();
+  const isRead = PRISMA_READ_METHODS.has(method);
+  const isWrite = PRISMA_WRITE_METHODS.has(method);
+  if (!isRead && !isWrite) {
+    return null;
+  }
+  const receiverExpr = delegateExpr.getExpression();
+  if (!isPrismaClientReceiver(receiverExpr)) {
+    return null;
+  }
+  const delegateName = delegateExpr.getName();
+  const tableName = capitalizeFirst(delegateName);
+  if (tableName === null) {
+    return null;
+  }
+  const kind = isRead ? "read" : "write";
+  const argsShape = recognizerCtx.extractArgs();
+  const optionsArg = readObjectArg(argsShape[0]);
+  const fields = extractFields(optionsArg, kind);
+  const selector = extractSelector(optionsArg);
+  const binding = storageBinding({
+    recognition: "@suss/framework-prisma",
+    storageSystem,
+    scope,
+    container: tableName
+  });
+  const callee = callNode.getExpression().getText();
+  return [
+    {
+      type: "interaction",
+      binding,
+      callee,
+      interaction: {
+        class: "storage-access",
+        kind,
+        fields,
+        ...selector !== null ? { selector } : {},
+        operation: method
+      }
+    },
+    ...nestedReads(optionsArg).map(
+      (nested) => ({
+        type: "interaction",
+        binding,
+        callee,
+        interaction: {
+          class: "storage-access",
+          kind: "read",
+          fields: nested.fields,
+          relationPath: nested.relationPath,
+          operation: method
+        }
+      })
+    ),
+    ...nestedWrites(optionsArg).map(
+      (nested) => ({
+        type: "interaction",
+        binding,
+        callee,
+        interaction: {
+          class: "storage-access",
+          kind: "write",
+          fields: nested.fields,
+          relationPath: nested.relationPath,
+          ...nested.relationKey === true ? { relationKey: true } : {},
+          // What reaches the other model is the nested operation, so
+          // that is what the effect records. The outer method belongs
+          // to the model in the binding.
+          operation: nested.operation
+        }
+      })
+    )
+  ];
+}
+function nestedReads(optionsArg) {
+  if (optionsArg === null) {
+    return [];
+  }
+  const found = [];
+  collectRelations(optionsArg, [], found);
+  return found;
+}
+function collectRelations(shape, path, found) {
+  const select = readObjectArg(shape.fields.select);
+  if (select !== null) {
+    for (const [name, value] of Object.entries(select.fields)) {
+      const nested = readObjectArg(value);
+      if (nested === null) {
+        continue;
+      }
+      recordRelation(name, nested, path, found);
+    }
+  }
+  const include = readObjectArg(shape.fields.include);
+  if (include === null) {
+    return;
+  }
+  for (const [name, value] of Object.entries(include.fields)) {
+    const nested = readObjectArg(value);
+    if (nested === null) {
+      found.push({ relationPath: [...path, name], fields: ["*"] });
+      continue;
+    }
+    recordRelation(name, nested, path, found);
+  }
+}
+function recordRelation(name, nested, path, found) {
+  const relationPath = [...path, name];
+  found.push({ relationPath, fields: extractFields(nested, "read") });
+  collectRelations(nested, relationPath, found);
+}
+var rowIsPayload = (payload) => {
+  const read = objectsIn(payload);
+  return { fields: fieldsOfRows(read), rows: read.rows };
+};
+function rowsUnder(...keys) {
+  return (payload) => {
+    const outer = objectsIn(payload);
+    const rows = [];
+    let written = outer.written && outer.rows.length > 0;
+    for (const entry of outer.rows) {
+      for (const key of keys) {
+        const inner = objectsIn(entry.fields[key]);
+        rows.push(...inner.rows);
+        written = written && inner.written;
+      }
+    }
+    return { fields: fieldsOfRows({ rows, written }), rows };
+  };
+}
+var updateRow = (payload) => {
+  const outer = objectsIn(payload);
+  const statesData = outer.rows.some((row) => "data" in row.fields);
+  return statesData ? rowsUnder("data")(payload) : rowIsPayload(payload);
+};
+var wholeRow = () => ({ fields: ["*"], rows: [] });
+var NESTED_OPERATIONS = /* @__PURE__ */ new Map([
+  ["create", { rows: rowIsPayload }],
+  ["createMany", { rows: rowsUnder("data") }],
+  ["connectOrCreate", { rows: rowsUnder("create"), movesJoin: true }],
+  ["update", { rows: updateRow }],
+  ["updateMany", { rows: rowsUnder("data") }],
+  ["upsert", { rows: rowsUnder("create", "update") }],
+  ["delete", { rows: wholeRow }],
+  ["deleteMany", { rows: wholeRow }],
+  ["connect", { movesJoin: true }],
+  ["disconnect", { movesJoin: true }],
+  ["set", { movesJoin: true }]
+]);
+function nestedWrites(optionsArg) {
+  if (optionsArg === null) {
+    return [];
+  }
+  const found = [];
+  for (const key of WRITE_PAYLOAD_KEYS) {
+    for (const row of objectsIn(optionsArg.fields[key]).rows) {
+      collectNestedWrites(row, [], found);
+    }
+  }
+  return found;
+}
+function collectNestedWrites(row, path, found) {
+  for (const [field, value] of Object.entries(row.fields)) {
+    const nested = readObjectArg(value);
+    if (nested === null) {
+      continue;
+    }
+    const relationPath = [...path, field];
+    for (const [operation, payload] of Object.entries(nested.fields)) {
+      const does = NESTED_OPERATIONS.get(operation);
+      if (does === void 0) {
+        continue;
+      }
+      if (does.rows !== void 0) {
+        const written = does.rows(payload);
+        found.push({ relationPath, fields: written.fields, operation });
+        for (const deeper of written.rows) {
+          collectNestedWrites(deeper, relationPath, found);
+        }
+      }
+      if (does.movesJoin === true) {
+        found.push({ relationPath, fields: [], operation, relationKey: true });
+      }
+    }
+  }
+}
+function objectsIn(arg) {
+  const object = readObjectArg(arg);
+  if (object !== null) {
+    return { rows: [object], written: true };
+  }
+  if (arg === null || arg === void 0 || typeof arg !== "object" || arg.kind !== "array") {
+    return { rows: [], written: false };
+  }
+  const rows = [];
+  let written = true;
+  for (const item of arg.items) {
+    const row = readObjectArg(item);
+    if (row === null) {
+      written = false;
+      continue;
+    }
+    rows.push(row);
+  }
+  return { rows, written };
+}
+function fieldsOfRows(read) {
+  if (!read.written) {
+    return ["*"];
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const row of read.rows) {
+    for (const key of Object.keys(row.fields)) {
+      out.add(key);
+    }
+  }
+  return out.size === 0 ? ["*"] : [...out];
+}
+function isPrismaClientReceiver(node) {
+  const type = node.getType();
+  if (type === null || typeof type !== "object") {
+    return false;
+  }
+  const symbol = type.getSymbol?.();
+  if (symbol === null || symbol === void 0) {
+    return false;
+  }
+  const decls = symbol.getDeclarations?.() ?? [];
+  for (const decl of decls) {
+    const declSourceFile = decl.getSourceFile();
+    const filePath = declSourceFile.getFilePath();
+    if (filePath.includes("/@prisma/client/") || filePath.includes("/.prisma/client/")) {
+      return true;
+    }
+  }
+  return false;
+}
+function capitalizeFirst(name) {
+  if (name.length === 0) {
+    return null;
+  }
+  return name[0].toUpperCase() + name.slice(1);
+}
+function readObjectArg(arg) {
+  if (arg === null || arg === void 0) {
+    return null;
+  }
+  if (typeof arg !== "object") {
+    return null;
+  }
+  if (arg.kind !== "object") {
+    return null;
+  }
+  return arg;
+}
+function extractFields(optionsArg, kind) {
+  if (optionsArg === null) {
+    return ["*"];
+  }
+  if (kind === "read") {
+    const select = readObjectArg(optionsArg.fields.select);
+    const include = readObjectArg(optionsArg.fields.include);
+    if (select === null) {
+      return ["*"];
+    }
+    const out = /* @__PURE__ */ new Set();
+    for (const k of Object.keys(select.fields)) {
+      out.add(k);
+    }
+    if (include !== null) {
+      for (const k of Object.keys(include.fields)) {
+        out.add(k);
+      }
+    }
+    return [...out];
+  }
+  const stated = /* @__PURE__ */ new Map();
+  for (const propName of WRITE_PAYLOAD_KEYS) {
+    const prop = readObjectArg(optionsArg.fields[propName]);
+    if (prop === null) {
+      continue;
+    }
+    for (const [name, value] of Object.entries(prop.fields)) {
+      stated.set(name, value);
+    }
+  }
+  if (stated.size === 0) {
+    return ["*"];
+  }
+  const columns = [];
+  for (const [name, value] of stated) {
+    if (statesNestedOperations(value)) {
+      continue;
+    }
+    columns.push(name);
+  }
+  return columns;
+}
+function statesNestedOperations(value) {
+  const nested = readObjectArg(value);
+  if (nested === null) {
+    return false;
+  }
+  return Object.keys(nested.fields).some((key) => NESTED_OPERATIONS.has(key));
+}
+function extractSelector(optionsArg) {
+  if (optionsArg === null) {
+    return null;
+  }
+  const where = readObjectArg(optionsArg.fields.where);
+  if (where === null) {
+    return null;
+  }
+  const keys = Object.keys(where.fields);
+  return keys.length > 0 ? keys : null;
+}
+function makeRawRecognizer(opts) {
+  const storageSystem = opts.storageSystem ?? "postgresql";
+  const scope = opts.scope ?? "default";
+  return ((node) => {
+    const statement = rawStatementAt(node);
+    if (statement === null) {
+      return null;
+    }
+    const accesses = readSqlAccess(statement.sql, { dialect: storageSystem });
+    if (accesses.length === 0) {
+      return null;
+    }
+    return accesses.map((access) => ({
+      type: "interaction",
+      binding: storageBinding({
+        recognition: "@suss/framework-prisma",
+        storageSystem,
+        scope,
+        container: access.table
+      }),
+      callee: statement.callee,
+      interaction: {
+        class: "storage-access",
+        kind: access.kind,
+        fields: access.fields,
+        ...access.selector.length > 0 ? { selector: access.selector } : {},
+        operation: statement.method
+      }
+    }));
+  });
+}
+function rawStatementAt(node) {
+  const tag = N.isTaggedTemplateExpression(node) ? node.getTag() : N.isCallExpression(node) ? node.getExpression() : null;
+  if (tag === null || !N.isPropertyAccessExpression(tag)) {
+    return null;
+  }
+  const method = tag.getName();
+  if (!RAW_METHODS.has(method)) {
+    return null;
+  }
+  if (!isPrismaClientReceiver(tag.getExpression())) {
+    return null;
+  }
+  const sql = N.isTaggedTemplateExpression(node) ? templateSql(node.getTemplate()) : N.isCallExpression(node) ? literalSql(node.getArguments()[0]) : null;
+  return sql === null ? null : { sql, method, callee: tag.getText() };
+}
+function templateSql(template) {
+  if (N.isNoSubstitutionTemplateLiteral(template)) {
+    return template.getLiteralValue();
+  }
+  if (!N.isTemplateExpression(template)) {
+    return null;
+  }
+  return sqlFromParts([
+    template.getHead().getLiteralText(),
+    ...template.getTemplateSpans().map((span) => span.getLiteral().getLiteralText())
+  ]);
+}
+function literalSql(argument) {
+  if (argument === void 0) {
+    return null;
+  }
+  if (N.isStringLiteral(argument) || N.isNoSubstitutionTemplateLiteral(argument)) {
+    return argument.getLiteralValue();
+  }
+  return N.isTemplateExpression(argument) ? templateSql(argument) : null;
+}
+function prismaFramework(options = {}) {
+  return {
+    name: "prisma",
+    protocol: "in-process",
+    languages: ["typescript", "javascript"],
+    discovery: [],
+    terminals: [],
+    inputMapping: { type: "positionalParams", params: [] },
+    // Skip files that don't import from @prisma/client: the
+    // recognizer's type-resolution check would reject them anyway.
+    requiresImport: ["@prisma/client"],
+    invocationRecognizers: [makeRecognizer(options)],
+    accessRecognizers: [makeRawRecognizer(options)]
+  };
+}
+var index_default = prismaFramework;
+export {
+  index_default as default
+};

package/dist/react-router.d.ts

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

package/dist/react-router.js

@@ -0,0 +1,197 @@
+// ../framework/react-router/dist/index.js
+var RESPONSE_MODULES = [
+  "react-router",
+  "react-router-dom",
+  "@remix-run/node",
+  "@remix-run/cloudflare",
+  "@remix-run/deno",
+  "@remix-run/server-runtime"
+];
+var HTTP_ERRORS_CODES = {
+  BadRequest: 400,
+  Unauthorized: 401,
+  PaymentRequired: 402,
+  Forbidden: 403,
+  NotFound: 404,
+  MethodNotAllowed: 405,
+  NotAcceptable: 406,
+  RequestTimeout: 408,
+  Conflict: 409,
+  Gone: 410,
+  PayloadTooLarge: 413,
+  UnsupportedMediaType: 415,
+  ImATeapot: 418,
+  UnprocessableEntity: 422,
+  TooManyRequests: 429,
+  InternalServerError: 500,
+  NotImplemented: 501,
+  BadGateway: 502,
+  ServiceUnavailable: 503,
+  GatewayTimeout: 504
+};
+var ROUTER_MODULES = ["react-router", "react-router-dom"];
+var JSX_ROUTES = {
+  type: "jsxElementRoute",
+  importModule: ROUTER_MODULES,
+  routeElement: "Route",
+  pathAttribute: "path",
+  elementAttribute: "element",
+  indexAttribute: "index",
+  childrenAttribute: "children",
+  routeObjectFactories: ["createBrowserRouter"],
+  elementsFactories: ["createRoutesFromElements"],
+  method: "GET"
+};
+function reactRouterFramework(options = {}) {
+  return {
+    name: "react-router",
+    protocol: "http",
+    languages: ["typescript", "javascript"],
+    discovery: [
+      {
+        kind: "loader",
+        match: { type: "namedExport", names: ["loader"] },
+        // No route derived from the filename. React Router only
+        // reads routes that way when the project opted in by
+        // importing @react-router/fs-routes, and the pack language
+        // has no way to say "only when that import is there". A
+        // loader whose route came out of a guess pairs with whatever
+        // consumer matches the guess, which is worse than pairing
+        // with nothing.
+        // Empty gate: route files often re-export `loader` /
+        // `action` from non-router-importing modules
+        // (server-side data functions, shared util re-exports).
+        // A heuristic gate would miss those. The dispatch only
+        // looks at named exports, so paying for the walk on
+        // every file is fine.
+        requiresImport: []
+      },
+      {
+        kind: "action",
+        match: { type: "namedExport", names: ["action"] },
+        // No route derived from the filename. React Router only
+        // reads routes that way when the project opted in by
+        // importing @react-router/fs-routes, and the pack language
+        // has no way to say "only when that import is there". A
+        // loader whose route came out of a guess pairs with whatever
+        // consumer matches the guess, which is worse than pairing
+        // with nothing.
+        requiresImport: []
+      },
+      {
+        kind: "component",
+        match: { type: "namedExport", names: ["default"] },
+        requiresImport: []
+      },
+      {
+        // The route tree the app declares in its own JSX, which is how
+        // most React Router apps say what serves which URL. Gated on
+        // the router import, since the whole pattern is written with
+        // names that come out of it.
+        kind: "component",
+        match: JSX_ROUTES,
+        requiresImport: ROUTER_MODULES
+      }
+    ],
+    terminals: [
+      {
+        // json(data, init?), for example `return json({ user })`
+        kind: "response",
+        match: {
+          type: "functionCall",
+          functionName: "json",
+          // These names come from the router, so a same-named helper
+          // the project wrote is a different function, with its own
+          // argument order, and must not match.
+          requiresImport: RESPONSE_MODULES
+        },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // data(value, init?), React Router v7's replacement for json()
+        kind: "response",
+        match: {
+          type: "functionCall",
+          functionName: "data",
+          // These names come from the router, so a same-named helper
+          // the project wrote is a different function, with its own
+          // argument order, and must not match.
+          requiresImport: RESPONSE_MODULES
+        },
+        extraction: {
+          body: { from: "argument", position: 0 },
+          defaultStatusCode: 200
+        }
+      },
+      {
+        // redirect(url, status?), for example `return redirect("/login")`
+        kind: "response",
+        match: {
+          type: "functionCall",
+          functionName: "redirect",
+          // These names come from the router, so a same-named helper
+          // the project wrote is a different function, with its own
+          // argument order, and must not match.
+          requiresImport: RESPONSE_MODULES
+        },
+        extraction: {
+          statusCode: { from: "argument", position: 1 },
+          defaultStatusCode: 302
+        }
+      },
+      {
+        // What a routed component renders. The route says which
+        // URL reaches this component, and the JSX it returns is what
+        // that URL renders, so the pack reads both rather than
+        // reporting the route and nothing behind it.
+        kind: "render",
+        match: { type: "jsxReturn" },
+        extraction: {}
+      },
+      {
+        // Loaders return data directly
+        kind: "return",
+        match: { type: "returnShape" },
+        extraction: {
+          body: { from: "argument", position: 0 }
+        }
+      },
+      // A project's error helper puts the status in the class name of its
+      // argument, so resolve through `argumentConstructor` rather
+      // than taking the argument's raw source text as a status value.
+      ...(options.errorHelpers ?? []).map((helper) => ({
+        kind: "throw",
+        match: {
+          type: "throwExpression",
+          constructorPattern: helper
+        },
+        extraction: {
+          statusCode: {
+            from: "argumentConstructor",
+            position: 0,
+            codes: HTTP_ERRORS_CODES
+          },
+          body: { from: "argument", position: 1 }
+        },
+        // The router turns the thrown error's status into the wire response.
+        producesResponse: true
+      }))
+    ],
+    inputMapping: {
+      type: "singleObjectParam",
+      paramPosition: 0,
+      knownProperties: {
+        request: "request",
+        params: "pathParams",
+        context: "context"
+      }
+    }
+  };
+}
+var index_default = reactRouterFramework;
+export {
+  index_default as default
+};

package/dist/react.d.ts

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