@suss/packs 0.12.0 → 0.13.0

package/dist/mongoose.js

@@ -1,377 +1,156 @@
 // ../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 }
+  constructedFrom,
+  declaredBy,
+  pack,
+  storageCalls
+} from "@suss/recognize";
+var CLIENT_MODULE = "mongoose";
+var WHOLE_DOCUMENT = ["*"];
+var BY_ID = ["_id"];
+var FILTER_KEYS = ({ input }) => keysOf(input);
+var PROJECTED = ({ input }) => {
+  const written = input.text();
+  if (written !== null) {
+    return namedInProjection(written);
+  }
+  const asked = keysOf(input, asksForIt);
+  return asked.length > 0 ? asked : WHOLE_DOCUMENT;
 };
-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)) {
+var UPDATED = ({ input }) => {
+  const touched = /* @__PURE__ */ new Set();
+  for (const entry of input.entries("nothing")) {
+    if (entry.key === null) {
       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)) {
+    if (!entry.key.startsWith(OPERATOR_PREFIX)) {
+      touched.add(entry.key);
       continue;
     }
-    const init = decl.getInitializer();
-    const identity = init === void 0 ? null : resolveDocumentModelIdentity(init, resolve);
-    if (identity !== null) {
-      return identity;
+    for (const name of keysOf(entry.value)) {
+      touched.add(name);
     }
   }
-  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 ["*"];
+  return touched.size > 0 ? [...touched] : WHOLE_DOCUMENT;
+};
+var PAYLOAD = ({ input }) => {
+  const documents = input.items();
+  if (documents.length === 0) {
+    const written = keysOf(input);
+    return written.length > 0 ? written : WHOLE_DOCUMENT;
   }
-  const fields = /* @__PURE__ */ new Set();
-  for (const [key, value] of Object.entries(object.fields)) {
-    if (!key.startsWith("$")) {
-      fields.add(key);
-      continue;
+  const union = /* @__PURE__ */ new Set();
+  for (const document of documents) {
+    const written = keysOf(document);
+    if (written.length === 0) {
+      return WHOLE_DOCUMENT;
     }
-    const operand = readObjectArg(value);
-    for (const inner of Object.keys(operand?.fields ?? {})) {
-      fields.add(inner);
+    for (const name of written) {
+      union.add(name);
     }
   }
-  return fields.size > 0 ? [...fields] : ["*"];
+  return [...union];
+};
+var OPERATOR_PREFIX = "$";
+function asksForIt(value) {
+  return value.flag() === true;
 }
-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);
+function keysOf(value, keep = () => true) {
+  const found = [];
+  for (const entry of value.entries("nothing")) {
+    if (entry.key !== null && keep(entry.value)) {
+      found.push(entry.key);
     }
   }
-  return union.size > 0 ? [...union] : ["*"];
+  return found;
 }
-function distinctField(arg) {
-  return arg !== null && typeof arg === "object" && arg.kind === "string" ? [arg.value] : [];
+function namedInProjection(written) {
+  const asked = written.trim().split(/\s+/).filter((term) => term.length > 0 && !term.startsWith("-")).map((term) => term.replace(/^\+/, ""));
+  return asked.length > 0 ? asked : WHOLE_DOCUMENT;
 }
-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]);
+var filter = (at) => ({ of: { at }, by: FILTER_KEYS });
+var projection = (at) => ({ of: { at }, by: PROJECTED });
+var update = (at) => ({ of: { at }, by: UPDATED });
+var payload = (at) => ({ of: { at }, by: PAYLOAD });
+var METHODS = {
+  find: { kind: "read", selector: filter(0), fields: projection(1) },
+  findOne: { kind: "read", selector: filter(0), fields: projection(1) },
+  findById: { kind: "read", selector: BY_ID, fields: projection(1) },
+  countDocuments: { kind: "read", selector: filter(0) },
+  exists: { kind: "read", selector: filter(0) },
+  distinct: { kind: "read", selector: filter(1), fields: { at: 0 } },
+  create: { kind: "write", fields: payload(0) },
+  insertMany: { kind: "write", fields: payload(0) },
+  updateOne: { kind: "write", selector: filter(0), fields: update(1) },
+  updateMany: { kind: "write", selector: filter(0), fields: update(1) },
+  replaceOne: { kind: "write", selector: filter(0), fields: payload(1) },
+  deleteOne: { kind: "write", selector: filter(0), fields: WHOLE_DOCUMENT },
+  deleteMany: { kind: "write", selector: filter(0), fields: WHOLE_DOCUMENT },
+  findOneAndUpdate: { kind: "write", selector: filter(0), fields: update(1) },
+  findByIdAndUpdate: { kind: "write", selector: BY_ID, fields: update(1) },
+  findOneAndDelete: {
+    kind: "write",
+    selector: filter(0),
+    fields: WHOLE_DOCUMENT
+  },
+  findByIdAndDelete: { kind: "write", selector: BY_ID, fields: WHOLE_DOCUMENT },
+  findOneAndReplace: { kind: "write", selector: filter(0), fields: payload(1) },
+  // A document can be changed after it was built, which this does not
+  // track, so a save is not reported as touching the fields the
+  // constructor happened to state.
+  save: { kind: "write", fields: WHOLE_DOCUMENT }
+};
+var MODEL_FACTORY = "model";
+function collectionOf(_selector, call) {
+  const model = modelCallIn(call);
+  const modelName = model?.nameAt(0, "nothing") ?? null;
+  if (model === null || modelName === null) {
+    return null;
   }
-  return spec.kind === "write" ? ["*"] : [];
+  return model.nameAt(2, "nothing") ?? schemaCollectionOf(model) ?? pluralized(modelName);
 }
-function selectorOf(spec, args) {
-  if (spec.idArg !== void 0) {
-    return args[spec.idArg] !== void 0 ? ["_id"] : null;
-  }
-  if (spec.filterArg === void 0) {
+function modelCallIn(call) {
+  const receiver = call.receiver();
+  if (receiver === null) {
     return null;
   }
-  const object = readObjectArg(args[spec.filterArg]);
-  if (object === null) {
+  return modelFactoryCall(receiver) ?? modelFactoryCall(receiver.callee()) ?? modelFactoryCall(receiver.receiver());
+}
+function modelFactoryCall(call) {
+  if (call === null) {
     return null;
   }
-  const keys = Object.keys(object.fields);
-  return keys.length > 0 ? keys : null;
+  const named = call.method() ?? call.calleeText();
+  const fromLibrary = call.isFrom(constructedFrom(CLIENT_MODULE));
+  return named === MODEL_FACTORY && fromLibrary ? call : 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 schemaCollectionOf(model) {
+  return model.argument(1)?.propertyAt(1, "collection", "nothing") ?? null;
 }
-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 pluralized(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 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 modelCalls(scope) {
+  return storageCalls({
+    system: "mongodb",
+    scope,
+    client: declaredBy(CLIENT_MODULE),
+    unsettledName: "nothing"
+  }).methods(METHODS).container(collectionOf).example('User.find({ email: "a@b.c" }, { name: 1 })');
 }
 function mongooseFramework(options = {}) {
-  const scope = options.scope ?? "default";
-  return {
-    name: "mongoose",
-    protocol: "in-process",
+  return pack("mongoose", [modelCalls(options.scope ?? "default")], {
     languages: ["typescript", "javascript"],
-    discovery: [],
-    terminals: [],
-    inputMapping: { type: "positionalParams", params: [] },
-    requiresImport: ["mongoose"],
-    invocationRecognizers: [
-      makeStaticRecognizer(scope),
-      makeSaveRecognizer(scope)
-    ]
-  };
+    recognizedAs: "@suss/framework-mongoose",
+    protocol: "in-process"
+  });
 }
 var index_default = mongooseFramework;
 export {

package/dist/prisma.js

@@ -3,13 +3,12 @@ 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"
-]);
+import {
+  compile,
+  declarationsIn,
+  declaredBy,
+  sqlStatements
+} from "@suss/recognize";
 var PRISMA_READ_METHODS = /* @__PURE__ */ new Set([
   "findUnique",
   "findFirst",
@@ -360,74 +359,23 @@ function extractSelector(optionsArg) {
   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;
+var STATEMENT = { statement: { at: 0 } };
+function rawStatements(options) {
+  const provider = options.storageSystem ?? "postgresql";
+  return sqlStatements({
+    system: provider,
+    dialect: provider,
+    scope: options.scope ?? "default",
+    client: declaredBy("@prisma/client", ".prisma/client")
+  }).methods({
+    $queryRaw: STATEMENT,
+    $executeRaw: STATEMENT,
+    $queryRawUnsafe: STATEMENT,
+    $executeRawUnsafe: STATEMENT
+  }).example('prisma.$queryRawUnsafe("SELECT id, email FROM users")');
 }
 function prismaFramework(options = {}) {
+  const raw = rawStatements(options);
   return {
     name: "prisma",
     protocol: "in-process",
@@ -439,7 +387,10 @@ function prismaFramework(options = {}) {
     // recognizer's type-resolution check would reject them anyway.
     requiresImport: ["@prisma/client"],
     invocationRecognizers: [makeRecognizer(options)],
-    accessRecognizers: [makeRawRecognizer(options)]
+    // A tagged template is not an invocation, so the raw chain runs on
+    // the access walk, which visits calls as well.
+    accessRecognizers: [compile(raw.declared, "@suss/framework-prisma")],
+    declarations: declarationsIn([raw])
   };
 }
 var index_default = prismaFramework;

package/dist/react-router.js

@@ -181,8 +181,7 @@ function reactRouterFramework(options = {}) {
       }))
     ],
     inputMapping: {
-      type: "singleObjectParam",
-      paramPosition: 0,
+      type: "objectParam",
       knownProperties: {
         request: "request",
         params: "pathParams",

package/dist/ts-rest.js

@@ -68,7 +68,7 @@ function tsRestFramework() {
       paramsExtraction: { property: "pathParams" }
     },
     inputMapping: {
-      type: "destructuredObject",
+      type: "objectParam",
       knownProperties: {
         params: "pathParams",
         body: "requestBody",