@suss/packs 0.33.0 → 0.34.0

package/dist/typeorm.js

@@ -0,0 +1,291 @@
+// ../framework/typeorm/dist/index.js
+import { z } from "zod";
+import { scopeOption, storageSystemOption } from "@suss/extractor";
+import {
+  constructedFrom,
+  pack,
+  sqlStatements,
+  storageCalls
+} from "@suss/recognize";
+import fs from "fs";
+import path from "path";
+import { ts } from "ts-morph";
+var STORAGE_SYSTEM_OF_DRIVER = {
+  postgres: "postgresql",
+  "aurora-postgres": "postgresql",
+  mysql: "mysql",
+  mariadb: "mysql",
+  "aurora-mysql": "mysql",
+  sqlite: "sqlite",
+  "better-sqlite3": "sqlite",
+  sqljs: "sqlite"
+};
+var UNPAIRED_DRIVERS = /* @__PURE__ */ new Set([
+  "cockroachdb",
+  "mssql",
+  "oracle",
+  "sap",
+  "spanner",
+  "mongodb"
+]);
+var CONNECTION_FACTORIES = /* @__PURE__ */ new Set(["forRoot", "forRootAsync"]);
+var INSTALLED_PACKAGES = "node_modules";
+var SOURCE_FILE = /\.(?:[cm]?ts|[cm]?js)$/;
+function storageSystemFromDataSource(projectRoot) {
+  const systems = /* @__PURE__ */ new Set();
+  for (const file of sourceFilesUnder(projectRoot)) {
+    const text = fs.readFileSync(file, "utf8");
+    if (!text.includes("typeorm")) {
+      continue;
+    }
+    for (const driver of driversIn(file, text)) {
+      if (UNPAIRED_DRIVERS.has(driver)) {
+        return null;
+      }
+      const system = STORAGE_SYSTEM_OF_DRIVER[driver];
+      if (system !== void 0) {
+        systems.add(system);
+      }
+    }
+  }
+  const [only] = systems;
+  return systems.size === 1 && only !== void 0 ? { storageSystem: only } : null;
+}
+function sourceFilesUnder(dir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!entry.name.startsWith(".") && entry.name !== INSTALLED_PACKAGES) {
+        files.push(...sourceFilesUnder(full));
+      }
+      continue;
+    }
+    if (entry.isFile() && SOURCE_FILE.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+function driversIn(file, text) {
+  const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest);
+  const found = [];
+  const visit = (node) => {
+    const options = connectionOptionsOf(node);
+    if (options !== void 0) {
+      found.push(...stringTypesIn(options, source));
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return found;
+}
+function connectionOptionsOf(node) {
+  if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "DataSource") {
+    return node.arguments?.[0];
+  }
+  if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && CONNECTION_FACTORIES.has(node.expression.name.text) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "TypeOrmModule") {
+    return node.arguments[0];
+  }
+  return void 0;
+}
+function stringTypesIn(options, source) {
+  const found = [];
+  const visit = (node) => {
+    if (ts.isPropertyAssignment(node) && node.name.getText(source) === "type" && ts.isStringLiteralLike(node.initializer)) {
+      found.push(node.initializer.text);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(options);
+  return found;
+}
+var NEST_MODULE = "@nestjs/typeorm";
+var TYPEORM_MODULE = "typeorm";
+var INJECT_REPOSITORY = "InjectRepository";
+var INJECT_DATA_SOURCE = "InjectDataSource";
+var INJECT_ENTITY_MANAGER = "InjectEntityManager";
+var WHOLE_ROW = ["*"];
+var CONDITION_COLUMNS = ({ input }) => {
+  const conditions = input.items();
+  if (conditions.length === 0) {
+    return keysOf(input);
+  }
+  return [...new Set(conditions.flatMap((condition2) => keysOf(condition2)))];
+};
+var SELECTED = ({ input }) => {
+  const listed = input.items().map((item) => item.text()).filter((name) => name !== null);
+  if (listed.length > 0) {
+    return listed;
+  }
+  const flagged = keysOf(input, (value) => value.flag() !== false);
+  return flagged.length > 0 ? flagged : WHOLE_ROW;
+};
+var PAYLOAD = ({ input }) => {
+  const entities = input.items();
+  if (entities.length === 0) {
+    const written = keysOf(input);
+    return written.length > 0 ? written : WHOLE_ROW;
+  }
+  const union = /* @__PURE__ */ new Set();
+  for (const entity of entities) {
+    const written = keysOf(entity);
+    if (written.length === 0) {
+      return WHOLE_ROW;
+    }
+    for (const name of written) {
+      union.add(name);
+    }
+  }
+  return [...union];
+};
+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 found;
+}
+var optionsWhere = {
+  of: { at: 0, property: ["where"] },
+  by: CONDITION_COLUMNS
+};
+var optionsSelect = {
+  of: { at: 0, property: ["select"] },
+  by: SELECTED
+};
+var condition = (at) => ({
+  of: { at },
+  by: CONDITION_COLUMNS
+});
+var payload = (at) => ({ of: { at }, by: PAYLOAD });
+var REPOSITORY_METHODS = {
+  find: { kind: "read", selector: optionsWhere, fields: optionsSelect },
+  findOne: { kind: "read", selector: optionsWhere, fields: optionsSelect },
+  findOneOrFail: {
+    kind: "read",
+    selector: optionsWhere,
+    fields: optionsSelect
+  },
+  findAndCount: {
+    kind: "read",
+    selector: optionsWhere,
+    fields: optionsSelect
+  },
+  count: { kind: "read", selector: optionsWhere },
+  exists: { kind: "read", selector: optionsWhere },
+  findBy: { kind: "read", selector: condition(0), fields: WHOLE_ROW },
+  findOneBy: { kind: "read", selector: condition(0), fields: WHOLE_ROW },
+  findOneByOrFail: { kind: "read", selector: condition(0), fields: WHOLE_ROW },
+  findAndCountBy: { kind: "read", selector: condition(0), fields: WHOLE_ROW },
+  countBy: { kind: "read", selector: condition(0) },
+  existsBy: { kind: "read", selector: condition(0) },
+  save: { kind: "write", fields: payload(0) },
+  insert: { kind: "write", fields: payload(0) },
+  upsert: { kind: "write", fields: payload(0) },
+  update: { kind: "write", selector: condition(0), fields: payload(1) },
+  increment: { kind: "write", selector: condition(0), fields: { at: 1 } },
+  decrement: { kind: "write", selector: condition(0), fields: { at: 1 } },
+  delete: { kind: "write", selector: condition(0), fields: WHOLE_ROW },
+  softDelete: { kind: "write", selector: condition(0), fields: WHOLE_ROW },
+  restore: { kind: "write", selector: condition(0), fields: WHOLE_ROW },
+  // `remove` takes loaded entities and deletes them by primary key, which
+  // the call does not spell.
+  remove: { kind: "write", fields: WHOLE_ROW },
+  softRemove: { kind: "write", fields: WHOLE_ROW }
+};
+var ENTITY = constructedFrom({ from: [TYPEORM_MODULE], named: ["Entity"] });
+function tableOf(_selector, call) {
+  const entity = call.receiver()?.classAt?.(0) ?? null;
+  if (entity === null) {
+    return null;
+  }
+  const decorator = entity.decorator(ENTITY);
+  const stated = decorator?.propertyAt(0, "name", "nothing") ?? decorator?.nameAt(0, "nothing") ?? null;
+  if (stated !== null) {
+    return stated;
+  }
+  const className = entity.name();
+  return className === null ? null : snakeCase(className);
+}
+function snakeCase(name) {
+  return name.replace(/([A-Z])([A-Z])([a-z])/g, "$1_$2$3").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+var optionsSchema = z.object({
+  /**
+   * The storage system the calls target, `"postgresql"` when unset. It
+   * has to match the other side's `storageSystem`, or the calls do not
+   * pair.
+   */
+  storageSystem: storageSystemOption.optional(),
+  /** Scope for the storage binding, `"default"` when unset. */
+  scope: scopeOption.optional()
+}).strict();
+function repositoryCalls(options) {
+  return storageCalls({
+    system: options.storageSystem ?? "postgresql",
+    scope: options.scope ?? "default",
+    client: constructedFrom({
+      from: [NEST_MODULE],
+      named: [INJECT_REPOSITORY]
+    }),
+    unsettledName: "nothing"
+  }).methods(REPOSITORY_METHODS).container(tableOf).example('this.orders.find({ where: { status: "open" } })');
+}
+var STATEMENT = { statement: { at: 0 } };
+function rawStatements(options) {
+  const system = options.storageSystem ?? "postgresql";
+  return sqlStatements({
+    system,
+    dialect: system,
+    scope: options.scope ?? "default",
+    client: constructedFrom({
+      from: [NEST_MODULE],
+      named: [INJECT_DATA_SOURCE, INJECT_ENTITY_MANAGER]
+    })
+  }).methods({ query: STATEMENT }).example('this.source.query("SELECT id FROM orders")');
+}
+function typeormFramework(options = {}) {
+  return {
+    ...pack("typeorm", [repositoryCalls(options), rawStatements(options)], {
+      languages: ["typescript", "javascript"],
+      recognizedAs: "@suss/framework-typeorm",
+      protocol: "in-process"
+    }),
+    parameterSuppliers: [
+      INJECT_REPOSITORY,
+      INJECT_DATA_SOURCE,
+      INJECT_ENTITY_MANAGER
+    ].map((name) => ({ module: NEST_MODULE, name }))
+  };
+}
+var declares = {
+  kind: "effects",
+  package: "@suss/framework-typeorm",
+  dependencies: [{ ecosystem: "npm", name: NEST_MODULE }],
+  reads: "TypeORM repositories that NestJS injects with `@InjectRepository`. Each read and write becomes a storage-access interaction on the entity's table, and a `query` on an injected data source or entity manager is read as SQL.",
+  configuration: {
+    file: "suss.typeorm.json",
+    example: { storageSystem: "postgresql" },
+    required: false,
+    // The extract command init prints passes this file, so init always
+    // writes it, with the pack's own default when the project does not say.
+    defaults: { storageSystem: "postgresql" },
+    why: "which database the connection uses: postgresql, mysql, or sqlite. It assumes postgresql otherwise, and the calls do not pair with a store on another database.",
+    readFromProject: storageSystemFromDataSource
+  }
+};
+var index_default = typeormFramework;
+export {
+  declares,
+  index_default as default,
+  optionsSchema
+};

package/dist/vitest.d.ts

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

package/dist/vitest.js

@@ -0,0 +1,64 @@
+// ../framework/vitest/dist/index.js
+import { z } from "zod";
+var optionsSchema = z.object({
+  /**
+   * The test files to read, matched on whole path segments from the
+   * end. `suss extract --intent` fills it in from the tests the PRDs
+   * name, so a run reads those files and no others. Left out, every
+   * file that imports vitest is read.
+   */
+  files: z.array(z.string().min(1)).optional()
+}).strict();
+function vitestFramework(options = {}) {
+  return {
+    name: "vitest",
+    protocol: "in-process",
+    languages: ["typescript", "javascript"],
+    discovery: [
+      {
+        kind: "test",
+        match: {
+          type: "testCase",
+          style: "block",
+          importModule: "vitest",
+          suiteNames: ["describe", "suite"],
+          caseNames: ["it", "test"],
+          skipModifiers: ["skip", "todo"],
+          argumentModifiers: ["skipIf", "runIf"],
+          rowModifiers: ["each", "for"],
+          mocks: {
+            object: "vi",
+            moduleMethods: ["mock", "doMock"],
+            memberMethods: ["spyOn"]
+          },
+          ...options.files !== void 0 ? { files: options.files } : {}
+        },
+        requiresImport: ["vitest"]
+      }
+    ],
+    // What a test returns does not matter. Every way out of the body is
+    // a terminal so the calls on each path are recorded.
+    terminals: [
+      { kind: "return", match: { type: "returnStatement" }, extraction: {} },
+      { kind: "throw", match: { type: "throwExpression" }, extraction: {} },
+      {
+        kind: "return",
+        match: { type: "functionFallthrough" },
+        extraction: {}
+      }
+    ],
+    inputMapping: { type: "allPositional" }
+  };
+}
+var declares = {
+  kind: "framework",
+  package: "@suss/framework-vitest",
+  dependencies: [],
+  reads: "vitest cases, named by their titles, so a PRD scenario can say which test covers it."
+};
+var index_default = vitestFramework;
+export {
+  declares,
+  index_default as default,
+  optionsSchema
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/packs",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "type": "module",
   "description": "Every pack suss ships in one install, so it can read Express, Hono, NestJS, FastAPI, Rails, Prisma, OpenAPI and the rest.",
   "keywords": [
@@ -15,7 +15,7 @@
   ],
   "license": "Apache-2.0",
   "author": "Nimbus Cloud AI LLC",
-  "homepage": "https://github.com/nimbuscloud-ai/suss/tree/main/packages/packs#readme",
+  "homepage": "https://suss.sh",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nimbuscloud-ai/suss.git",
@@ -177,6 +177,22 @@
       "types": "./dist/pg-ruby.d.ts",
       "import": "./dist/pg-ruby.js"
     },
+    "./rspec": {
+      "types": "./dist/rspec.d.ts",
+      "import": "./dist/rspec.js"
+    },
+    "./factory-bot": {
+      "types": "./dist/factory-bot.d.ts",
+      "import": "./dist/factory-bot.js"
+    },
+    "./fabrication": {
+      "types": "./dist/fabrication.d.ts",
+      "import": "./dist/fabrication.js"
+    },
+    "./minitest": {
+      "types": "./dist/minitest.d.ts",
+      "import": "./dist/minitest.js"
+    },
     "./prisma": {
       "types": "./dist/prisma.d.ts",
       "import": "./dist/prisma.js"
@@ -209,6 +225,14 @@
       "types": "./dist/zustand.d.ts",
       "import": "./dist/zustand.js"
     },
+    "./vitest": {
+      "types": "./dist/vitest.d.ts",
+      "import": "./dist/vitest.js"
+    },
+    "./pytest": {
+      "types": "./dist/pytest.d.ts",
+      "import": "./dist/pytest.js"
+    },
     "./sqlalchemy": {
       "types": "./dist/sqlalchemy.d.ts",
       "import": "./dist/sqlalchemy.js"
@@ -220,6 +244,10 @@
     "./ts-rest": {
       "types": "./dist/ts-rest.d.ts",
       "import": "./dist/ts-rest.js"
+    },
+    "./typeorm": {
+      "types": "./dist/typeorm.d.ts",
+      "import": "./dist/typeorm.js"
     }
   },
   "files": [
@@ -238,15 +266,16 @@
     "ts-morph": "^23.0.0"
   },
   "dependencies": {
-    "@suss/adapter-python": "0.33.0",
-    "@suss/adapter-ruby": "0.33.0",
-    "@suss/adapter-typescript": "0.33.0",
-    "@suss/behavioral-ir": "0.33.0",
-    "@suss/contract-graphql": "0.33.0",
-    "@suss/extractor": "0.33.0",
-    "@suss/manifest-aws": "0.33.0",
-    "@suss/recognize": "0.33.0",
-    "@suss/sql": "0.33.0",
+    "@mrleebo/prisma-ast": "^0.15.0",
+    "@suss/adapter-python": "0.34.0",
+    "@suss/adapter-ruby": "0.34.0",
+    "@suss/adapter-typescript": "0.34.0",
+    "@suss/behavioral-ir": "0.34.0",
+    "@suss/contract-graphql": "0.34.0",
+    "@suss/extractor": "0.34.0",
+    "@suss/manifest-aws": "0.34.0",
+    "@suss/recognize": "0.34.0",
+    "@suss/sql": "0.34.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {
@@ -288,16 +317,23 @@
     "@suss/framework-package-exports": "*",
     "@suss/framework-pg": "*",
     "@suss/framework-pg-ruby": "*",
+    "@suss/framework-rspec": "*",
+    "@suss/framework-factory-bot": "*",
+    "@suss/framework-fabrication": "*",
+    "@suss/framework-minitest": "*",
     "@suss/framework-prisma": "*",
+    "@suss/framework-pytest": "*",
     "@suss/framework-rails": "*",
     "@suss/framework-react": "*",
     "@suss/framework-react-query": "*",
     "@suss/framework-zustand": "*",
+    "@suss/framework-vitest": "*",
     "@suss/framework-react-router": "*",
     "@suss/framework-redis": "*",
     "@suss/framework-sqlalchemy": "*",
     "@suss/framework-sqlmodel": "*",
     "@suss/framework-ts-rest": "*",
+    "@suss/framework-typeorm": "*",
     "@suss/runtime-node": "*",
     "tsup": "*",
     "typescript": "*",