@suss/packs 0.31.2 → 0.33.0

package/dist/activerecord.d.ts

@@ -11,6 +11,9 @@ import '@suss/framework-aws-sns';
 import '@suss/framework-aws-sqs';
 import '@suss/framework-aws-ssm';
 import '@suss/client-axios';
+import '@suss/framework-bigquery-python';
+import '@suss/framework-bigquery-ruby';
+import '@suss/framework-bigquery';
 import '@suss/framework-cloudflare-workers';
 import '@suss/framework-drizzle';
 import '@suss/framework-express';
@@ -31,6 +34,8 @@ import '@suss/client-net-http';
 import '@suss/framework-nextjs';
 import '@suss/runtime-node';
 import '@suss/framework-package-exports';
+import '@suss/framework-pg-ruby';
+import '@suss/framework-pg';
 import '@suss/framework-prisma';
 import '@suss/framework-rails';
 import '@suss/framework-react-query';

package/dist/activerecord.js

@@ -98,6 +98,58 @@ var RETURNS_A_RELATION = [
   "except"
 ];
 var READS = [...RUNS_A_QUERY, ...RETURNS_A_RELATION, "not"];
+var TAKES_A_STATEMENT = {
+  find_by_sql: { at: 0 },
+  count_by_sql: { at: 0 }
+};
+var CONNECTION_STATEMENTS = {
+  execute: { at: 0 },
+  exec_query: { at: 0 },
+  exec_insert: { at: 0 },
+  exec_update: { at: 0 },
+  exec_delete: { at: 0 },
+  select_all: { at: 0 },
+  select_one: { at: 0 },
+  select_value: { at: 0 },
+  select_values: { at: 0 },
+  select_rows: { at: 0 }
+};
+var EVENT_OF = {
+  create: ["create"],
+  "create!": ["create"],
+  find_or_create_by: ["create"],
+  "find_or_create_by!": ["create"],
+  save: ["create", "update"],
+  "save!": ["create", "update"],
+  update: ["update"],
+  "update!": ["update"],
+  touch: ["update"],
+  upsert: ["create", "update"],
+  destroy: ["destroy"],
+  "destroy!": ["destroy"],
+  destroy_all: ["destroy"]
+};
+var REGISTERED_BY = {
+  before_validation: ["create", "update"],
+  after_validation: ["create", "update"],
+  before_save: ["create", "update"],
+  around_save: ["create", "update"],
+  after_save: ["create", "update"],
+  before_create: ["create"],
+  around_create: ["create"],
+  after_create: ["create"],
+  before_update: ["update"],
+  around_update: ["update"],
+  after_update: ["update"],
+  before_destroy: ["destroy"],
+  around_destroy: ["destroy"],
+  after_destroy: ["destroy"],
+  after_commit: ["create", "update", "destroy"],
+  after_rollback: ["create", "update", "destroy"],
+  after_create_commit: ["create"],
+  after_update_commit: ["update"],
+  after_destroy_commit: ["destroy"]
+};
 function activeRecordStorage(options) {
   return [
     {
@@ -131,6 +183,13 @@ function activeRecordStorage(options) {
         methods: ["find", "exists?", "update", "destroy", "delete"],
         column: "id"
       },
+      statements: TAKES_A_STATEMENT,
+      bindPlaceholder: "?",
+      callbacks: {
+        eventOf: EVENT_OF,
+        registeredBy: REGISTERED_BY,
+        eventKeyword: "on"
+      },
       columnArguments: ["select", "pluck", "pick"],
       associations: {
         singular: ["has_one", "belongs_to"],
@@ -141,6 +200,18 @@ function activeRecordStorage(options) {
     }
   ];
 }
+function activeRecordRawSql(options) {
+  return [
+    {
+      constantName: "ActiveRecord::Base",
+      baseClasses: ["ActiveRecord::Base"],
+      clientBuilders: ["connection", "lease_connection", "retrieve_connection"],
+      statements: CONNECTION_STATEMENTS,
+      storageSystem: options.storageSystem,
+      dialect: options.storageSystem
+    }
+  ];
+}
 function activeRecordFramework(options) {
   if (typeof options?.storageSystem !== "string") {
     throw new Error(
@@ -151,7 +222,8 @@ function activeRecordFramework(options) {
     name: "activerecord",
     protocol: options.storageSystem,
     discovery: [],
-    storage: activeRecordStorage(options)
+    storage: activeRecordStorage(options),
+    rawSql: activeRecordRawSql(options)
   };
 }
 var declares = {
@@ -161,7 +233,7 @@ var declares = {
     { ecosystem: "rubygems", name: "activerecord" },
     { ecosystem: "rubygems", name: "rails" }
   ],
-  reads: "ActiveRecord calls (Ruby): a call matches when its method is one ActiveRecord defines as a read or a write and the class behind its receiver reaches `ActiveRecord::Base`, following what each class extends through the project.",
+  reads: "ActiveRecord calls (Ruby): a call matches when its method is one ActiveRecord defines as a read or a write and the class behind its receiver reaches `ActiveRecord::Base`, following what each class extends through the project. Statements the project wrote itself are read for the tables they touch, whether they went through `find_by_sql` and `count_by_sql` or through the connection. A write also runs the model's callbacks, and what they reach lands on the body that did the write.",
   configuration: {
     file: "suss.activerecord.json",
     example: { storageSystem: "postgresql" },

package/dist/aws-lambda.js

@@ -413,6 +413,18 @@ function awsLambdaFramework(_options = {}) {
         { position: 1, role: "context" }
       ]
     },
+    // A proxy integration hands the handler API Gateway's event. The
+    // body arrives on it as a string the handler parses, so a read of
+    // it says the body was taken whole and never which field.
+    requestSpelling: {
+      headers: { path: ["event", "headers"], saysWhichField: true },
+      query: {
+        path: ["event", "queryStringParameters"],
+        saysWhichField: true
+      },
+      params: { path: ["event", "pathParameters"], saysWhichField: true },
+      body: { path: ["event", "body"], saysWhichField: false }
+    },
     // The powertools read their configuration from inside node_modules,
     // so a template that declares these has a reader no walk ever sees.
     libraryEnvVars: [

package/dist/axios.js

@@ -40,7 +40,8 @@ function discoveryForVerb(verb, factories) {
         importModule: "axios",
         importName: "axios",
         methodFilter: [verb],
-        factoryMethods: ["create"]
+        factoryMethods: ["create"],
+        basePathOption: "baseURL"
       },
       bindingExtraction: {
         method: { type: "literal", value: verb.toUpperCase() },
@@ -56,7 +57,8 @@ function discoveryForVerb(verb, factories) {
         type: "clientCall",
         importModule: factory.module,
         importName: factory.export,
-        methodFilter: [verb]
+        methodFilter: [verb],
+        basePathOption: "baseURL"
       },
       bindingExtraction: {
         method: { type: "literal", value: verb.toUpperCase() },
@@ -101,7 +103,8 @@ function configCallDiscovery(factories) {
         importName: "axios",
         methodFilter: ["request"],
         factoryMethods: ["create"],
-        callable: true
+        callable: true,
+        basePathOption: "baseURL"
       },
       bindingExtraction,
       requiresImport: ["axios"]
@@ -114,7 +117,8 @@ function configCallDiscovery(factories) {
         type: "clientCall",
         importModule: factory.module,
         importName: factory.export,
-        methodFilter: ["request"]
+        methodFilter: ["request"],
+        basePathOption: "baseURL"
       },
       bindingExtraction,
       requiresImport: isPathShapedSpecifier(factory.module) ? [] : [factory.module]

package/dist/bigquery-python.d.ts

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

package/dist/bigquery-python.js

@@ -0,0 +1,122 @@
+// ../framework/bigquery-python/dist/index.js
+var STORAGE_SYSTEM = "gcp.bigquery";
+var DIALECT = "bigquery";
+var CLIENT_MODULE = "google.cloud.bigquery";
+var HOOK_MODULE = "airflow.providers.google.cloud.hooks.bigquery";
+var CLIENT_STATEMENTS = [
+  { method: "query", argument: 0, keyword: "query" },
+  { method: "query_and_wait", argument: 0, keyword: "query" }
+];
+var CLIENT_TABLES = [
+  { method: "get_table", argument: 0, keyword: "table", kind: "read" },
+  { method: "list_rows", argument: 0, keyword: "table", kind: "read" },
+  {
+    method: "insert_rows",
+    argument: 0,
+    keyword: "table",
+    kind: "write"
+  },
+  {
+    method: "insert_rows_json",
+    argument: 0,
+    keyword: "table",
+    kind: "write"
+  },
+  {
+    method: "delete_table",
+    argument: 0,
+    keyword: "table",
+    kind: "write"
+  },
+  {
+    method: "load_table_from_dataframe",
+    argument: 1,
+    keyword: "destination",
+    kind: "write"
+  },
+  {
+    method: "load_table_from_json",
+    argument: 1,
+    keyword: "destination",
+    kind: "write"
+  },
+  {
+    method: "load_table_from_uri",
+    argument: 1,
+    keyword: "destination",
+    kind: "write"
+  },
+  {
+    method: "load_table_from_file",
+    argument: 1,
+    keyword: "destination",
+    kind: "write"
+  }
+];
+var HOOK_STATEMENTS = [
+  { method: "get_records", argument: 0, keyword: "sql" },
+  { method: "get_first", argument: 0, keyword: "sql" },
+  { method: "get_pandas_df", argument: 0, keyword: "sql" },
+  { method: "run_query", argument: 0, keyword: "sql" },
+  {
+    method: "insert_job",
+    argument: 0,
+    keyword: "configuration",
+    path: ["query", "query"]
+  }
+];
+var HOOK_TABLES = [
+  {
+    method: "delete_table",
+    argument: 0,
+    keyword: "table_id",
+    kind: "write"
+  }
+];
+function bigqueryClients() {
+  return [
+    {
+      module: CLIENT_MODULE,
+      clientTypes: ["Client"],
+      statements: CLIENT_STATEMENTS,
+      tables: CLIENT_TABLES,
+      storageSystem: STORAGE_SYSTEM,
+      dialect: DIALECT
+    },
+    {
+      module: HOOK_MODULE,
+      clientTypes: ["BigQueryHook"],
+      statements: HOOK_STATEMENTS,
+      tables: HOOK_TABLES,
+      // The hook documents `get_client` as handing back the client
+      // library's own `Client`, so a chain off it reads as one.
+      handsBack: [
+        { method: "get_client", module: CLIENT_MODULE, name: "Client" }
+      ],
+      storageSystem: STORAGE_SYSTEM,
+      dialect: DIALECT
+    }
+  ];
+}
+function bigqueryFramework() {
+  return {
+    name: "bigquery-python",
+    protocol: STORAGE_SYSTEM,
+    discovery: [],
+    sqlClients: bigqueryClients()
+  };
+}
+var declares = {
+  kind: "effects",
+  package: "@suss/framework-bigquery-python",
+  dependencies: [
+    { ecosystem: "pypi", name: "google-cloud-bigquery" },
+    { ecosystem: "pypi", name: "apache-airflow-providers-google" }
+  ],
+  reads: "BigQuery calls (Python): the statement a client or an Airflow hook is handed, read for the tables it touches, and the calls that say which table without writing SQL."
+};
+var index_default = bigqueryFramework;
+export {
+  declares,
+  index_default as default
+};

package/dist/bigquery-ruby.d.ts

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

package/dist/bigquery-ruby.js

@@ -0,0 +1,56 @@
+// ../framework/bigquery-ruby/dist/index.js
+var STORAGE_SYSTEM = "gcp.bigquery";
+var DIALECT = "bigquery";
+var ADDRESSING = {
+  dataset: { says: "scope", at: 0 },
+  table: { says: "container", at: 0 }
+};
+var STATEMENTS = {
+  query: { at: 0 },
+  query_job: { at: 0 }
+};
+var ROW_CALLS = {
+  insert: { kind: "write", container: { at: 0 } },
+  insert_async: { kind: "write", container: { at: 0 } },
+  load: { kind: "write", container: { at: 0 } },
+  load_job: { kind: "write", container: { at: 0 } },
+  data: { kind: "read" },
+  "exists?": { kind: "read" },
+  delete: { kind: "write" }
+};
+function bigqueryRawSql() {
+  const calls = {
+    addressing: ADDRESSING,
+    statements: STATEMENTS,
+    rowCalls: ROW_CALLS,
+    storageSystem: STORAGE_SYSTEM,
+    dialect: DIALECT
+  };
+  return [
+    {
+      constantName: "Google::Cloud::Bigquery",
+      clientBuilders: ["new"],
+      ...calls
+    },
+    { constantName: "Google::Cloud", clientBuilders: ["bigquery"], ...calls }
+  ];
+}
+function bigqueryRubyFramework() {
+  return {
+    name: "bigquery-ruby",
+    protocol: STORAGE_SYSTEM,
+    discovery: [],
+    rawSql: bigqueryRawSql()
+  };
+}
+var declares = {
+  kind: "effects",
+  package: "@suss/framework-bigquery-ruby",
+  dependencies: [{ ecosystem: "rubygems", name: "google-cloud-bigquery" }],
+  reads: "google-cloud-bigquery calls (Ruby): a call matches when its receiver follows back to a client the gem handed out, and the statement it was given is parsed for the tables it touches."
+};
+var index_default = bigqueryRubyFramework;
+export {
+  declares,
+  index_default as default
+};

package/dist/bigquery.d.ts

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

package/dist/bigquery.js

@@ -0,0 +1,54 @@
+// ../framework/bigquery/dist/index.js
+import { declaredBy, pack, sqlStatements, storageCalls } from "@suss/recognize";
+var CLIENT_MODULE = "@google-cloud/bigquery";
+var STORAGE_SYSTEM = "gcp.bigquery";
+var STATEMENT = {
+  statement: [{ at: 0 }, { at: 0, property: ["query"] }]
+};
+var QUERIES = sqlStatements({
+  system: STORAGE_SYSTEM,
+  dialect: "bigquery",
+  client: declaredBy(CLIENT_MODULE)
+}).methods({
+  query: STATEMENT,
+  createQueryJob: STATEMENT,
+  createQueryStream: STATEMENT
+}).example(
+  'bigquery.query("SELECT id, name FROM `analytics.core.dim_account`")'
+);
+var DATASET_STEP = { to: "receiver", method: "dataset" };
+var TABLE_STEP = { to: "receiver", method: "table" };
+var TABLE = { of: [TABLE_STEP], at: 0 };
+var DATASET = { of: [DATASET_STEP], at: 0 };
+var READ_ROWS = { kind: "read", fields: ["*"] };
+var WRITE_ROWS = { kind: "write", fields: ["*"] };
+var READ_TABLE = { kind: "read" };
+var DROP_TABLE = { kind: "write" };
+var OPERATIONS = {
+  insert: WRITE_ROWS,
+  load: WRITE_ROWS,
+  getRows: READ_ROWS,
+  exists: READ_TABLE,
+  delete: DROP_TABLE
+};
+var TABLE_CALLS = storageCalls({
+  system: STORAGE_SYSTEM,
+  client: declaredBy(CLIENT_MODULE)
+}).methods(OPERATIONS).container(TABLE).scope(DATASET).example('bigquery.dataset("core").table("dim_account").insert(rows)');
+function bigqueryFramework() {
+  return pack("bigquery", [QUERIES, TABLE_CALLS], {
+    languages: ["typescript", "javascript"],
+    recognizedAs: "@suss/framework-bigquery"
+  });
+}
+var declares = {
+  kind: "effects",
+  package: "@suss/framework-bigquery",
+  dependencies: [{ ecosystem: "npm", name: "@google-cloud/bigquery" }],
+  reads: "BigQuery queries and table calls, emits storage-access interactions with the dataset as the scope."
+};
+var index_default = bigqueryFramework;
+export {
+  declares,
+  index_default as default
+};

package/dist/express.js

@@ -173,6 +173,14 @@ function expressFramework(_options = {}) {
         { position: 1, role: "response" },
         { position: 2, role: "next" }
       ]
+    },
+    // Express puts all four parts on the request object, and a handler
+    // reads a field of each by name.
+    requestSpelling: {
+      headers: { path: ["request", "headers"], saysWhichField: true },
+      query: { path: ["request", "query"], saysWhichField: true },
+      params: { path: ["request", "params"], saysWhichField: true },
+      body: { path: ["request", "body"], saysWhichField: true }
     }
   };
 }

package/dist/fastify.js

@@ -118,6 +118,14 @@ function fastifyFramework(_options = {}) {
         { position: 0, role: "request" },
         { position: 1, role: "reply" }
       ]
+    },
+    // Fastify puts all four parts on the request object, and a handler
+    // reads a field of each by name.
+    requestSpelling: {
+      headers: { path: ["request", "headers"], saysWhichField: true },
+      query: { path: ["request", "query"], saysWhichField: true },
+      params: { path: ["request", "params"], saysWhichField: true },
+      body: { path: ["request", "body"], saysWhichField: true }
     }
   };
 }

package/dist/graphql-ruby.js

@@ -109,7 +109,10 @@ function graphqlRubyFramework(options) {
           "dataload_all",
           "dataload_record",
           "dataload_all_records"
-        ]
+        ],
+        // The library runs `fetch` on the source class `with` was given,
+        // so whatever that method reaches belongs to the field.
+        source: { at: 0, method: "fetch" }
       }
     ]
   };

package/dist/hono.js

@@ -208,6 +208,14 @@ function honoFramework(_options = {}) {
     inputMapping: {
       type: "positionalParams",
       params: [{ position: 0, role: "context" }]
+    },
+    // `c.req.header("x-tenant-id")` puts the field in the argument, and
+    // a read records the method without it, so no read says which field.
+    requestSpelling: {
+      headers: { path: ["context", "req", "header"], saysWhichField: false },
+      query: { path: ["context", "req", "query"], saysWhichField: false },
+      params: { path: ["context", "req", "param"], saysWhichField: false },
+      body: { path: ["context", "req", "json"], saysWhichField: false }
     }
   };
 }