@suss/recognize 0.12.0 → 0.13.0

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/compile.ts
 import { storageBinding } from "@suss/behavioral-ir";
+import { readSqlAccess, sqlFromParts } from "@suss/sql";
 
 // src/ops.ts
 function declaredBy(...importedFrom) {
@@ -14,104 +15,297 @@ function opsIn(ctx) {
 }
 
 // src/compile.ts
+var MAX_RECEIVER_HOPS = 8;
 function compile(chain, recognition) {
   return (_call, ctx) => {
     const ops = opsIn(ctx);
-    if (ops === null) {
+    const methods = methodsIn(chain);
+    if (ops === null || methods === null) {
       return null;
     }
-    const method = ops.method();
-    if (method === null) {
-      return null;
-    }
-    const meaning = meaningOf(chain, method);
-    if (meaning === null || !startsHere(chain, ops)) {
-      return null;
+    for (const subject of subjectsOf(chain, ops)) {
+      const method = operationOf(subject);
+      const meaning = method === null ? null : listed(methods, method);
+      if (method === null || meaning === null || !startsHere(chain, subject)) {
+        continue;
+      }
+      return YIELD[chain.ending.yields]({
+        ops,
+        subject,
+        method,
+        meaning,
+        chain,
+        recognition
+      });
     }
-    return YIELD[chain.ending.yields]({
-      ops,
-      method,
-      meaning,
-      chain,
-      recognition
-    });
+    return null;
   };
 }
-function meaningOf(chain, method) {
-  const link = chain.links.find(
-    (candidate) => candidate.asks === "methods"
-  );
-  if (link === void 0) {
-    return null;
-  }
+function linkIn(chain, asks) {
+  const link = chain.links.find((candidate) => candidate.asks === asks);
+  return link ?? null;
+}
+function methodsIn(chain) {
+  return linkIn(chain, "methods");
+}
+function operationOf(ops) {
+  return ops.method() ?? ops.calleeText();
+}
+function listed(link, method) {
   if (!link.ignoringCase) {
     return link.table[method] ?? null;
   }
   return link.table[method.toLowerCase()] ?? null;
 }
+function subjectsOf(chain, ops) {
+  const link = linkIn(chain, "subject");
+  return link === null ? [ops] : walk([ops], link.of);
+}
+var STEP = {
+  receiver: (step, ops) => receiversOf(ops, step.method),
+  argument: (step, ops) => argumentsOf(ops, step)
+};
+function walk(from, steps) {
+  let reached = [...from];
+  for (const step of steps) {
+    reached = reached.flatMap((ops) => STEP[step.to](step, ops));
+  }
+  return reached;
+}
+function receiversOf(ops, method) {
+  let step = ops.receiver();
+  for (let hops = 0; step !== null && hops < MAX_RECEIVER_HOPS; hops += 1) {
+    if (method === void 0 || step.method() === method) {
+      return [step];
+    }
+    step = step.receiver();
+  }
+  return [];
+}
+function argumentsOf(ops, step) {
+  const found = [];
+  for (const index of positions(ops, step.at)) {
+    const argument = ops.argument(index);
+    if (argument !== null && cameFrom(argument, step.origin)) {
+      found.push(argument);
+    }
+  }
+  return found;
+}
+function cameFrom(argument, origin) {
+  return origin === void 0 || argument.isFrom(origin);
+}
+function positions(ops, pick) {
+  if (typeof pick === "number") {
+    return [pick];
+  }
+  const first = "at" in pick ? pick.at : pick.from;
+  const last = "at" in pick ? pick.at + 1 : ops.argumentCount();
+  const found = [];
+  for (let index = first; index < last; index += 1) {
+    found.push(index);
+  }
+  return found;
+}
 var START = {
   receiver: (start, ops) => ops.receiverIsFrom(start.origin)
 };
-function startsHere(chain, ops) {
+function startsHere(chain, subject) {
   return chain.links.every(
-    (link) => link.asks === "start" ? START[link.at.starts](link.at, ops) : true
+    (link) => link.asks === "start" ? START[link.at.starts](link.at, subject) : true
   );
 }
 var YIELD = {
-  storageAccess
+  storageAccess,
+  sqlAccess
 };
 function storageAccess(matched) {
-  const { ops, method, meaning, chain, recognition } = matched;
+  const { subject, chain } = matched;
+  const meaning = matched.meaning;
+  const unsettled = chain.ending.unsettledName;
+  const kind = kindOf(meaning.kind, subject, unsettled);
+  const link = linkIn(chain, "input");
+  const input = link === null ? null : statedValue(subject, link.at);
+  if (kind === null || link !== null && input === null) {
+    return null;
+  }
+  return reachedBy(chain, subject, unsettled).map(
+    (reached) => accessEffect(matched, { input, kind, reached, unsettled })
+  );
+}
+function accessEffect(matched, access) {
+  const { ops, subject, method, chain, recognition } = matched;
+  const meaning = matched.meaning;
   const ending = chain.ending;
-  const selector = namesAt(ops, meaning.selector, ending.unsettledName);
-  const fields = namesAt(ops, meaning.fields, ending.unsettledName);
-  const container = containerOf(chain, selector, ops);
-  return [
-    {
-      type: "interaction",
-      binding: storageBinding({
-        recognition,
-        storageSystem: ending.system,
-        ...ending.transport === void 0 ? {} : { transport: ending.transport },
-        scope: ending.scope,
-        container,
-        accessPath: null
-      }),
-      callee: ops.calleeText(),
-      interaction: {
-        class: "storage-access",
-        kind: meaning.kind,
-        fields,
-        operation: method,
-        ...selector.length > 0 ? { selector } : {}
-      }
+  const { input, kind, reached, unsettled } = access;
+  const stated = { input, entry: reached.entry, kind };
+  const selector = namesFor(meaning.selector, subject, stated, unsettled);
+  const fields = namesFor(meaning.fields, subject, stated, unsettled);
+  return {
+    type: "interaction",
+    binding: storageBinding({
+      recognition,
+      storageSystem: ending.system,
+      ...ending.transport === void 0 ? {} : { transport: ending.transport },
+      scope: ending.scope,
+      container: reached.entry === null ? containerOf(chain, selector, subject, unsettled) : reached.container,
+      accessPath: accessPathOf(chain, subject, unsettled)
+    }),
+    callee: ops.calleeText(),
+    interaction: {
+      class: "storage-access",
+      kind,
+      fields,
+      operation: namesAt(subject, meaning.operation, unsettled)[0] ?? method,
+      ...selector.length > 0 ? { selector } : {}
     }
-  ];
+  };
 }
-function containerOf(chain, selector, ops) {
-  const link = chain.links.find(
-    (candidate) => candidate.asks === "container"
-  );
-  if (link === void 0) {
+function reachedBy(chain, subject, unsettled) {
+  const link = linkIn(chain, "containers");
+  const map = link === null ? null : statedValue(subject, link.in);
+  if (map === null) {
+    return [{ container: null, entry: null }];
+  }
+  return map.entries(unsettled).map((entry) => ({ container: entry.key, entry: entry.value }));
+}
+function kindOf(kind, subject, unsettled) {
+  if (typeof kind === "string") {
+    return kind;
+  }
+  const asked = kind;
+  const [answer] = namesAt(subject, asked.asks, unsettled);
+  const said = answer === void 0 ? void 0 : asked.means[answer];
+  return said ?? asked.otherwise ?? null;
+}
+function containerOf(chain, selector, subject, unsettled) {
+  const link = linkIn(chain, "container");
+  if (link === null) {
     return selector[0] ?? null;
   }
-  return link.from(selector, ops);
+  if ("from" in link) {
+    return link.from(selector, subject);
+  }
+  return namesAt(subject, link.argument, unsettled)[0] ?? null;
+}
+function accessPathOf(chain, subject, unsettled) {
+  const link = linkIn(chain, "accessPath");
+  return link === null ? null : namesAt(subject, link.argument, unsettled)[0] ?? null;
+}
+function statedValue(subject, pick) {
+  for (const ops of walk([subject], pick.of ?? [])) {
+    const stated = ops.valueAt(pick.at);
+    if (stated === null) {
+      continue;
+    }
+    if (pick.property === void 0) {
+      return stated;
+    }
+    for (const property of pick.property) {
+      const inside = stated.property(property);
+      if (inside !== null) {
+        return inside;
+      }
+    }
+  }
+  return null;
 }
-function namesAt(ops, pick, unsettled) {
+var NOTHING_STATED = {
+  text: () => null,
+  flag: () => null,
+  entries: () => [],
+  items: () => [],
+  property: () => null,
+  parts: () => null,
+  holes: () => []
+};
+function namesFor(says, subject, stated, unsettled) {
+  if (says === void 0) {
+    return [];
+  }
+  if (Array.isArray(says)) {
+    return [...says];
+  }
+  if (typeof says === "function") {
+    const input2 = stated.input;
+    return input2 === null ? [] : [...says({ ...stated, input: input2 })];
+  }
+  const pointed = says;
+  if (!("by" in pointed)) {
+    return namesAt(subject, pointed, unsettled);
+  }
+  const input = statedValue(subject, pointed.of) ?? NOTHING_STATED;
+  return [...pointed.by({ ...stated, input })];
+}
+function namesAt(subject, pick, unsettled) {
   if (pick === void 0) {
     return [];
   }
-  const last = "at" in pick ? pick.at + 1 : ops.argumentCount();
-  const first = "at" in pick ? pick.at : pick.from;
   const names = [];
-  for (let index = first; index < last; index += 1) {
-    const name = ops.nameAt(index, unsettled);
-    if (name !== null) {
-      names.push(name);
+  for (const ops of walk([subject], pick.of ?? [])) {
+    for (const index of positions(ops, pick)) {
+      const name = nameOf(ops, pick, index, unsettled);
+      if (name !== null) {
+        names.push(name);
+      }
     }
   }
   return names;
 }
+function nameOf(ops, pick, index, unsettled) {
+  if (pick.property === void 0) {
+    return ops.nameAt(index, unsettled);
+  }
+  for (const property of pick.property) {
+    const name = ops.propertyAt(index, property, unsettled);
+    if (name !== null) {
+      return name;
+    }
+  }
+  return null;
+}
+function sqlAccess(matched) {
+  const { ops, subject, method, chain, recognition } = matched;
+  const ending = chain.ending;
+  const stated = statedValue(subject, matched.meaning.statement);
+  const parts = stated?.parts() ?? null;
+  if (stated === null || parts === null) {
+    return null;
+  }
+  const statement = sqlFromParts(parts, namesInHoles(chain, stated));
+  const accesses = readSqlAccess(statement, { dialect: ending.dialect });
+  return accesses.length === 0 ? null : accesses.map((access) => ({
+    type: "interaction",
+    binding: storageBinding({
+      recognition,
+      storageSystem: ending.system,
+      ...ending.transport === void 0 ? {} : { transport: ending.transport },
+      scope: ending.scope,
+      container: access.table
+    }),
+    callee: ops.calleeText(),
+    interaction: {
+      class: "storage-access",
+      kind: access.kind,
+      fields: access.fields,
+      ...access.selector.length > 0 ? { selector: access.selector } : {},
+      operation: method
+    }
+  }));
+}
+function namesInHoles(chain, stated) {
+  const link = linkIn(chain, "interpolates");
+  if (link === null) {
+    return [];
+  }
+  return stated.holes().map((hole) => nameInHole(hole, link));
+}
+function nameInHole(hole, link) {
+  if (hole === null || link.from !== void 0 && !hole.isFrom(link.from)) {
+    return null;
+  }
+  return namesAt(hole, link.named, "nothing")[0] ?? null;
+}
 
 // src/example.ts
 function runExamples(pack2, run) {
@@ -134,24 +328,35 @@ function examplesMissing(pack2) {
 }
 
 // src/pack.ts
+var DISPATCHED_ON = {
+  storageAccess: "invocation",
+  sqlAccess: "access"
+};
+function walkedBy(chains, walk2, recognizedAs) {
+  return chains.filter((chain) => DISPATCHED_ON[chain.ending.yields] === walk2).map((chain) => compile(chain, recognizedAs));
+}
 function pack(name, matches, spec) {
   const chains = matches.map((match) => match.declared);
-  const recognizers = chains.map(
-    (chain) => compile(chain, spec.recognizedAs)
-  );
+  const access = walkedBy(chains, "access", spec.recognizedAs);
   return {
     name,
     languages: spec.languages,
     ...spec.version === void 0 ? {} : { version: spec.version },
-    protocol: protocolOf(chains),
+    protocol: spec.protocol ?? protocolOf(chains),
     discovery: [],
     terminals: [],
     inputMapping: { type: "positionalParams", params: [] },
-    requiresImport: gateOf(chains),
-    invocationRecognizers: recognizers,
-    declarations: { declarations: chains.map(describe) }
+    requiresImport: [
+      .../* @__PURE__ */ new Set([...gateOf(chains), ...spec.requiresImport ?? []])
+    ],
+    invocationRecognizers: walkedBy(chains, "invocation", spec.recognizedAs),
+    ...access.length === 0 ? {} : { accessRecognizers: access },
+    declarations: declarationsIn(matches)
   };
 }
+function declarationsIn(matches) {
+  return { declarations: matches.map((match) => describe(match.declared)) };
+}
 function protocolOf(chains) {
   const wires = new Set(
     chains.map((chain) => chain.ending.transport ?? chain.ending.system)
@@ -167,42 +372,97 @@ function protocolOf(chains) {
 function gateOf(chains) {
   const modules = /* @__PURE__ */ new Set();
   for (const chain of chains) {
-    for (const link of chain.links) {
-      if (link.asks !== "start" || link.at.starts !== "receiver") {
-        continue;
-      }
-      for (const module of link.at.origin.importedFrom) {
+    for (const origin of originsIn(chain)) {
+      for (const module of origin.importedFrom) {
         modules.add(module);
       }
     }
   }
   return [...modules];
 }
+function originsIn(chain) {
+  const found = [];
+  for (const link of chain.links) {
+    if (link.asks === "start" && link.at.starts === "receiver") {
+      found.push(link.at.origin);
+    }
+    if (link.asks === "interpolates" && link.from !== void 0) {
+      found.push(link.from);
+    }
+    if (link.asks !== "subject") {
+      continue;
+    }
+    for (const step of link.of) {
+      if (step.to === "argument" && step.origin !== void 0) {
+        found.push(step.origin);
+      }
+    }
+  }
+  return found;
+}
 function describe(chain) {
-  const functions = chain.links.filter(isFunctionLink);
+  const links = chain.links.filter(isFunctionLink);
+  const written = [
+    ...links.map((link) => ({
+      asks: link.asks,
+      reachesAst: link.from.reachesAst === true
+    })),
+    ...rulesIn(chain)
+  ];
   return {
     name: chain.ending.system,
-    dataLinks: chain.links.length - functions.length,
-    functionLinks: functions.map((link) => link.asks),
-    astLinks: functions.filter((link) => link.from.reachesAst === true).map((link) => link.asks),
+    // A method table with a rule inside it is still a table, so that
+    // link stays counted as data and the rule is priced beside it.
+    dataLinks: chain.links.length - links.length,
+    functionLinks: written.map((rule) => rule.asks),
+    astLinks: written.filter((rule) => rule.reachesAst).map((rule) => rule.asks),
     example: chain.example
   };
 }
 function isFunctionLink(link) {
-  return link.asks === "container";
+  return link.asks === "container" && "from" in link;
+}
+function rulesIn(chain) {
+  const link = chain.links.find(
+    (candidate) => candidate.asks === "methods"
+  );
+  const written = /* @__PURE__ */ new Map();
+  for (const method of Object.values(link?.table ?? {})) {
+    for (const asks of ["selector", "fields"]) {
+      const rule = ruleFor(method[asks]);
+      if (rule !== null) {
+        written.set(asks, rule);
+      }
+    }
+  }
+  return [...written].map(([asks, from]) => ({
+    asks,
+    reachesAst: from.reachesAst === true
+  }));
+}
+function ruleFor(says) {
+  if (typeof says === "function") {
+    return says;
+  }
+  if (says === void 0 || Array.isArray(says)) {
+    return null;
+  }
+  const pointed = says;
+  return "by" in pointed ? pointed.by : null;
 }
 
-// src/storage.ts
-function storageCalls(spec) {
+// src/sqlStatements.ts
+function sqlStatements(spec) {
   const ending = {
-    yields: "storageAccess",
+    yields: "sqlAccess",
     system: spec.system,
     ...spec.transport === void 0 ? {} : { transport: spec.transport },
     scope: spec.scope ?? "default",
-    unsettledName: spec.unsettledName ?? "reference"
+    dialect: spec.dialect
   };
+  const client = spec.client;
   return chainFrom({
-    links: [{ asks: "start", at: { starts: "receiver", origin: spec.client } }],
+    links: client === void 0 ? [] : [{ asks: "start", at: { starts: "receiver", origin: client } }],
     ending,
     example: null
   });
@@ -216,17 +476,55 @@ function chainFrom(declared) {
       table,
       ignoringCase: options?.ignoringCase ?? false
     }),
-    container: (from) => adding({ asks: "container", from }),
+    interpolating: (says) => adding({ asks: "interpolates", ...says }),
     example: (code) => chainFrom({ ...declared, example: code })
   };
 }
+
+// src/storage.ts
+function storageCalls(spec) {
+  const ending = {
+    yields: "storageAccess",
+    system: spec.system,
+    ...spec.transport === void 0 ? {} : { transport: spec.transport },
+    scope: spec.scope ?? "default",
+    unsettledName: spec.unsettledName ?? "reference"
+  };
+  const client = spec.client;
+  return chainFrom2({
+    links: client === void 0 ? [] : [{ asks: "start", at: { starts: "receiver", origin: client } }],
+    ending,
+    example: null
+  });
+}
+function chainFrom2(declared) {
+  const adding = (link) => chainFrom2({ ...declared, links: [...declared.links, link] });
+  return {
+    declared,
+    about: (...of) => adding({ asks: "subject", of }),
+    methods: (table, options) => adding({
+      asks: "methods",
+      table,
+      ignoringCase: options?.ignoringCase ?? false
+    }),
+    container: (says) => adding(
+      typeof says === "function" ? { asks: "container", from: says } : { asks: "container", argument: says }
+    ),
+    accessPath: (says) => adding({ asks: "accessPath", argument: says }),
+    containersIn: (says) => adding({ asks: "containers", in: says }),
+    input: (says) => adding({ asks: "input", at: says }),
+    example: (code) => chainFrom2({ ...declared, example: code })
+  };
+}
 export {
   compile,
   constructedFrom,
+  declarationsIn,
   declaredBy,
   examplesMissing,
   opsIn,
   pack,
   runExamples,
+  sqlStatements,
   storageCalls
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/recognize",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "type": "module",
   "description": "Write a pack as data: a chain of named links that any language adapter with the executor ops can run.",
   "keywords": [
@@ -49,8 +49,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@suss/behavioral-ir": "0.12.0",
-    "@suss/extractor": "0.12.0"
+    "@suss/behavioral-ir": "0.13.0",
+    "@suss/extractor": "0.13.0",
+    "@suss/sql": "0.13.0"
   },
   "devDependencies": {
     "tsup": "*",