@prismalyst/core 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prismalyst
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,210 @@
-# Temporary Holding Version
+# Prismalyst Core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Internal analysis engine and shared TypeScript contracts for the
+[Prismalyst ESLint plugin](https://github.com/Prismalyst/eslint-plugin).
+
+The core identifies Prisma calls and client construction through the TypeScript compiler API,
+extracts their arguments and context, and evaluates rules. Analysis does not execute Prisma queries
+or require a database connection.
+
+## Responsibilities
+
+| Core                                                        | ESLint plugin                                                        |
+| ----------------------------------------------------------- | -------------------------------------------------------------------- |
+| Recognize Prisma expressions using type information.        | Obtain the TypeScript program from ESLint parser services.           |
+| Parse arguments, source locations, and expression context.  | Map between TypeScript and ESLint AST nodes.                         |
+| Define rule behavior, option types, and registration.       | Define messages, severity, option validation, defaults, and presets. |
+| Return whether a rule triggers and which node to highlight. | Load schema metadata and report diagnostics through ESLint.          |
+
+The package exports ESM, CommonJS, and TypeScript declarations from `dist`. Changes to exported
+contracts must be coordinated with the plugin.
+
+## Development setup
+
+Use **Node.js 24** and **npm** to match [CI](.github/workflows/ci.yml). Run these commands from
+`prismalyst-core`:
+
+```sh
+npm ci
+npm run prisma:v7:generate
+```
+
+The generation step creates the ignored test client in `src/tests/schemas/v7/generated/prisma`.
+Repeat it after changing the [test schema](src/tests/schemas/v7/schema.prisma). Tests analyze source
+fixtures and use in-memory schema metadata; database setup and migrations are not required.
+
+The declared TypeScript peer range is `>=5.0.0 <7`. The current development dependency is TypeScript
+6, and the AST fixtures cover Prisma 7. The peer range alone does not establish compatibility with
+every Prisma generator or TypeScript version.
+
+## Checks and commands
+
+Run the same checks as CI before submitting a change:
+
+```sh
+npm run lint
+npm run typecheck
+npm run test:ci
+npm run build
+```
+
+`typecheck` checks production source; `tsconfig.json` excludes the tests. The build emits declarations
+and ESM files through TypeScript, then creates the CommonJS entry with Rollup.
+
+| Command                                   | Purpose                                                  |
+| ----------------------------------------- | -------------------------------------------------------- |
+| `npm run test:watch`                      | Run Vitest in watch mode.                                |
+| `npm run test:ci -- src/tests/unit/rules` | Run rule unit tests.                                     |
+| `npm run test:ci -- src/tests/ast/v7`     | Run Prisma expression and parser fixture tests.          |
+| `npm run watch`                           | Recompile TypeScript on source changes.                  |
+| `npm run pack:check`                      | Preview the package contents without creating a tarball. |
+
+## Project structure
+
+```text
+src/
+  ast/                Prisma expression detection, conversion, and parsing helpers
+  constants/          Shared Prisma method groups
+  rules/
+    list/             Rule implementations
+    types/            Rule names and their option types
+    utils/            Shared rule helpers
+    rules-list.ts     Rule registration and dispatch metadata
+  tests/
+    unit/             Isolated rule and utility tests
+    ast/v7/           Type-aware tests backed by TypeScript fixtures
+    schemas/v7/       Prisma schema and generated test client
+  types/              AST, Prisma expression, and rule contracts
+  index.ts            Package exports
+documentation/        One Markdown page per rule
+```
+
+## Core API
+
+The public entry point is [`src/index.ts`](src/index.ts).
+
+| Export                                               | Purpose                                                                          |
+| ---------------------------------------------------- | -------------------------------------------------------------------------------- |
+| `createAstUtils(ts, checker)`                        | Create node and Prisma helpers for a TypeScript analysis context.                |
+| `isPrismaExpression(node, program, astUtils)`        | Identify a supported Prisma call or client construction.                         |
+| `convertToPrismaExpression(node, program, astUtils)` | Extract arguments, locations, method, model, and context from a recognized node. |
+| `getProperty(argument, path)`                        | Read a nested parsed value while preserving its source node.                     |
+| `RULES_LIST`                                         | Access registered rules, their functions, and dispatch metadata.                 |
+| `ParsedValue`                                        | Type for a parsed value and its source nodes.                                    |
+| `OptionsByRuleName`                                  | Type mapping rule names to their option objects.                                 |
+| `RegisteredRule`                                     | Type linking a registered rule name to its function and options.                 |
+
+### Example: evaluating one rule
+
+This fragment assumes `program` is the host's `ts.Program` and `node` comes from that program's AST
+traversal. Create `astUtils` once per analysis context and reuse it while visiting nodes.
+
+```ts
+import {
+  RULES_LIST,
+  convertToPrismaExpression,
+  createAstUtils,
+  isPrismaExpression,
+} from '@prismalyst/core';
+import * as ts from 'typescript';
+
+const astUtils = createAstUtils(ts, program.getTypeChecker());
+const rule = RULES_LIST.find((candidate) => candidate.name === 'max-take');
+
+if (
+  rule?.name === 'max-take' &&
+  ts.isCallExpression(node) &&
+  isPrismaExpression(node, program, astUtils)
+) {
+  const expression = convertToPrismaExpression(node, program, astUtils);
+  const result = rule.function(expression, rule, { max: 100 });
+
+  if (result.isTriggered) {
+    console.log(rule.name, result.nodeToHighlight.getText());
+  }
+}
+```
+
+Call `convertToPrismaExpression` only after recognition. For general rule dispatch, use each rule's
+`astType`, `methods`, and `requireSchema` metadata. Match `callExpression` rules to call nodes and
+`newExpression` rules to construction nodes.
+
+Rules return `{ isTriggered: false }` or `{ isTriggered: true, nodeToHighlight }`. The host turns the
+reported TypeScript node into its own diagnostic. The core does not supply diagnostic messages or
+autofixes.
+
+Pass the complete option object as the third argument to a rule function, or `{}` for a rule without
+options. The core provides no option defaults or runtime validation. Schema-dependent rules accept
+Prisma's Data Model Meta Format (DMMF) document as the fourth argument and return no report when it is
+absent. Schema discovery and loading belong to the host integration.
+
+## Rules
+
+Each page documents the shipped behavior, reported and accepted examples, options, schema
+requirements, and known limits.
+
+| Rule                                                                            | Purpose                                                          | Requires schema |
+| ------------------------------------------------------------------------------- | ---------------------------------------------------------------- | --------------- |
+| [limit-relation-loading](documentation/limit-relation-loading.md)               | Require a separate `take` for each loaded list relation.         | Yes             |
+| [max-take](documentation/max-take.md)                                           | Require `take` and enforce its upper bound on `findMany`.        | No              |
+| [no-deep-offset-pagination](documentation/no-deep-offset-pagination.md)         | Keep `skip` within a configured range.                           | No              |
+| [no-disconnect-in-request-flow](documentation/no-disconnect-in-request-flow.md) | Restrict `$disconnect` to explicitly allowed files.              | No              |
+| [no-dynamic-raw-query](documentation/no-dynamic-raw-query.md)                   | Report interpolated templates passed to unsafe raw SQL methods.  | No              |
+| [no-floating-prisma-promise](documentation/no-floating-prisma-promise.md)       | Report Prisma promises without a recognized await or return.     | No              |
+| [no-prisma-client-in-function](documentation/no-prisma-client-in-function.md)   | Restrict client creation inside functions and methods.           | No              |
+| [no-query-in-loop](documentation/no-query-in-loop.md)                           | Report Prisma calls inside loops and selected array callbacks.   | No              |
+| [no-root-client-in-transaction](documentation/no-root-client-in-transaction.md) | Require the transaction client inside interactive transactions.  | No              |
+| [no-unindexed-filter](documentation/no-unindexed-filter.md)                     | Check top-level filter keys against schema indexes.              | Yes             |
+| [no-unsafe-prisma-raw](documentation/no-unsafe-prisma-raw.md)                   | Restrict `Prisma.raw` arguments to resolved strings.             | No              |
+| [no-unsafe-raw-sql](documentation/no-unsafe-raw-sql.md)                         | Report all calls to unsafe raw SQL methods.                      | No              |
+| [require-where-delete-many](documentation/require-where-delete-many.md)         | Require a nonempty `where` for `deleteMany`.                     | No              |
+| [require-where-update-many](documentation/require-where-update-many.md)         | Require a nonempty `where` for `updateMany`.                     | No              |
+| [unstable-pagination](documentation/unstable-pagination.md)                     | Require a unique ordering when `take` and `orderBy` are present. | Yes             |
+| [warn-cascade-delete](documentation/warn-cascade-delete.md)                     | Warn when deleting a model with incoming cascade relations.      | Yes             |
+
+Examples in the rule pages are TypeScript fragments. They assume a configured `prisma` client,
+generated Prisma exports where used, and models with the shown fields. `clientOptions` represents
+the application's client construction options. “Not reported” refers only to that page's rule;
+another rule or Prisma's types may still reject the code.
+
+### Adding or changing a rule
+
+1. Implement the behavior in `src/rules/list/<rule-name>.ts`. Keep parsing helpers in `src/ast` and
+   shared rule helpers in `src/rules/utils`.
+2. Add the rule's option contract in `src/rules/types/rules-options.types.ts`, including an entry for
+   rules with no options.
+3. Register the rule in `src/rules/rules-list.ts` with its name, AST type, methods, and schema
+   requirement. Add shared method names to `src/constants` if needed.
+4. Add focused tests in `src/tests/unit/rules`. Cover reports, accepted cases, method filtering,
+   options, and the highlighted node. For parser changes, add or update a fixture and its tests in
+   `src/tests/ast/v7`.
+5. Write or update `documentation/<rule-name>.md` and this rule table. Describe current behavior and
+   limits, and link the implementation and tests.
+6. Coordinate the plugin changes: messages, option schemas and defaults in `src/rules/rules.map.ts`,
+   preset entries in `src/config/create-configs.ts`, and integration tests in the plugin repository.
+
+## Core behavior
+
+Method groups come from
+[`prisma-methods.constants.ts`](src/constants/prisma-methods.constants.ts):
+
+- **CRUD methods:** `create`, `createMany`, `createManyAndReturn`, `findUnique`, `findUniqueOrThrow`,
+  `findFirst`, `findFirstOrThrow`, `findMany`, `update`, `updateMany`, `updateManyAndReturn`, `upsert`,
+  `delete`, and `deleteMany`.
+- **Read methods:** `findUnique`, `findUniqueOrThrow`, `findFirst`, `findFirstOrThrow`, and `findMany`.
+- **All registered Prisma methods:** CRUD methods plus `count`, `aggregate`, `groupBy`, `$queryRaw`,
+  `$executeRaw`, `$queryRawUnsafe`, `$executeRawUnsafe`, `$transaction`, `raw`, `sql`, `join`, `empty`,
+  `$db`, `$connect`, and `$disconnect`.
+
+Recognition depends on declarations from generated Prisma files. The current detection checks for
+`.prisma/client` or `generated/prisma` in declaration paths. Model resolution also depends on generated
+files under a `prisma/models` directory. Custom output layouts can therefore affect detection.
+
+The core handles TypeScript call and construction expressions. Tagged template expressions are not
+recognized directly. Parsed values can come from syntax, declarations, or types, and can remain
+unknown. Individual rules decide how to handle those values; analysis does not prove runtime query
+safety or database performance.
+
+## License
+
+[MIT](LICENSE).

package/dist/ast/parser/create-ast-parser.d.ts

@@ -0,0 +1,8 @@
+import type * as TS from 'typescript';
+export declare function createAstParser(ts: typeof TS): {
+    findVariableStatements: (sourceFile: TS.SourceFile) => TS.VariableStatement[];
+    findCallExpressions: (sourceFile: TS.SourceFile) => TS.CallExpression[];
+    findNewExpressions: (sourceFile: TS.SourceFile) => TS.NewExpression[];
+};
+export type AstParser = ReturnType<typeof createAstParser>;
+//# sourceMappingURL=create-ast-parser.d.ts.map

package/dist/ast/parser/create-ast-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-ast-parser.d.ts","sourceRoot":"","sources":["../../../src/ast/parser/create-ast-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAEtC,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,EAAE;yCACC,EAAE,CAAC,UAAU,KAAG,EAAE,CAAC,iBAAiB,EAAE;sCAgBzC,EAAE,CAAC,UAAU,KAAG,EAAE,CAAC,cAAc,EAAE;qCAgBpC,EAAE,CAAC,UAAU,KAAG,EAAE,CAAC,aAAa,EAAE;EAqB3E;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/ast/parser/create-ast-parser.js

@@ -0,0 +1,41 @@
+export function createAstParser(ts) {
+    function findVariableStatements(sourceFile) {
+        const statements = [];
+        function visit(node) {
+            if (ts.isVariableStatement(node)) {
+                statements.push(node);
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        return statements;
+    }
+    function findCallExpressions(sourceFile) {
+        const calls = [];
+        function visit(node) {
+            if (ts.isCallExpression(node)) {
+                calls.push(node);
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        return calls;
+    }
+    function findNewExpressions(sourceFile) {
+        const calls = [];
+        function visit(node) {
+            if (ts.isNewExpression(node)) {
+                calls.push(node);
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        return calls;
+    }
+    return {
+        findVariableStatements,
+        findCallExpressions,
+        findNewExpressions,
+    };
+}
+//# sourceMappingURL=create-ast-parser.js.map

package/dist/ast/parser/create-ast-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-ast-parser.js","sourceRoot":"","sources":["../../../src/ast/parser/create-ast-parser.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,eAAe,CAAC,EAAa;IAC3C,SAAS,sBAAsB,CAAC,UAAyB;QACvD,MAAM,UAAU,GAA2B,EAAE,CAAC;QAE9C,SAAS,KAAK,CAAC,IAAa;YAC1B,IAAI,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;gBACjC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACxB,CAAC;YAED,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,KAAK,CAAC,UAAU,CAAC,CAAC;QAElB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,SAAS,mBAAmB,CAAC,UAAyB;QACpD,MAAM,KAAK,GAAwB,EAAE,CAAC;QAEtC,SAAS,KAAK,CAAC,IAAa;YAC1B,IAAI,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC9B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnB,CAAC;YAED,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,KAAK,CAAC,UAAU,CAAC,CAAC;QAElB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,kBAAkB,CAAC,UAAyB;QACnD,MAAM,KAAK,GAAuB,EAAE,CAAC;QAErC,SAAS,KAAK,CAAC,IAAa;YAC1B,IAAI,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnB,CAAC;YAED,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,KAAK,CAAC,UAAU,CAAC,CAAC;QAElB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO;QACL,sBAAsB;QACtB,mBAAmB;QACnB,kBAAkB;KACnB,CAAC;AACJ,CAAC"}

package/dist/ast/prisma/convert-to-prisma-expression.d.ts

@@ -0,0 +1,5 @@
+import type * as TS from 'typescript';
+import { PrismaExpression, PrismaNodeExpression } from '../../types/prisma.types.js';
+import { AstUtils } from '../utils/create-ast-utils.js';
+export declare function convertToPrismaExpression(node: PrismaNodeExpression, program: TS.Program, { node: nodeUtils, prisma: prismaUtils }: AstUtils): PrismaExpression;
+//# sourceMappingURL=convert-to-prisma-expression.d.ts.map

package/dist/ast/prisma/convert-to-prisma-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-to-prisma-expression.d.ts","sourceRoot":"","sources":["../../../src/ast/prisma/convert-to-prisma-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAErF,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAGxD,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,EAAE,CAAC,OAAO,EACnB,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,QAAQ,GACjD,gBAAgB,CA+DlB"}

package/dist/ast/prisma/convert-to-prisma-expression.js

@@ -0,0 +1,58 @@
+import { defineMethod } from './utils/define-method.js';
+export function convertToPrismaExpression(node, program, { node: nodeUtils, prisma: prismaUtils }) {
+    const method = defineMethod(node, nodeUtils);
+    const { line: startLine, character: startCharacter } = node
+        .getSourceFile()
+        .getLineAndCharacterOfPosition(node.getStart());
+    const { line: endLine, character: endCharacter } = node
+        .getSourceFile()
+        .getLineAndCharacterOfPosition(node.getEnd());
+    const nodeLength = node.getWidth();
+    const filename = node.getSourceFile().fileName;
+    const args = node.arguments ?? [];
+    const checker = program.getTypeChecker();
+    const isFloatingPrismaPromise = prismaUtils.isFloatingPrismaPromise(node, node.parent, checker);
+    const isExpressionInsideTransaction = prismaUtils.isInsidePrismaTransaction(node);
+    const transactionType = prismaUtils.resolveTransactionType(node);
+    const clientType = prismaUtils.resolveClientType(node, checker);
+    const model = prismaUtils.resolveModelName(node, checker);
+    const isExpressionInsideLoop = nodeUtils.isInsideLoop(node);
+    const isExpressionInsideFunction = nodeUtils.isInsideFunction(node);
+    const isExpressionInsideClassMethod = nodeUtils.isInsideClassMethod(node);
+    const isExpressionInsideAwaitExpression = nodeUtils.isInsideAwaitExpression(node);
+    const parentFunctionName = nodeUtils.getParentFunctionName(node);
+    const parentMethodName = nodeUtils.getParentMethodName(node);
+    return {
+        node: node,
+        range: {
+            start: {
+                line: startLine,
+                character: startCharacter,
+            },
+            end: {
+                line: endLine,
+                character: endCharacter,
+            },
+            length: nodeLength,
+        },
+        filename,
+        expressionContext: {
+            isExpressionInsideLoop,
+            isExpressionInsideFunction,
+            isExpressionInsideClassMethod,
+            isExpressionInsideAwaitExpression,
+            parentFunctionName,
+            parentMethodName,
+        },
+        prismaContext: {
+            isFloatingPrismaPromise,
+            isExpressionInsideTransaction,
+            transactionType,
+            clientType,
+            model,
+        },
+        method,
+        args: args.map((argument) => nodeUtils.parseValue(argument, checker)),
+    };
+}
+//# sourceMappingURL=convert-to-prisma-expression.js.map

package/dist/ast/prisma/convert-to-prisma-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-to-prisma-expression.js","sourceRoot":"","sources":["../../../src/ast/prisma/convert-to-prisma-expression.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,MAAM,UAAU,yBAAyB,CACvC,IAA0B,EAC1B,OAAmB,EACnB,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAY;IAElD,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAE7C,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,cAAc,EAAE,GAAG,IAAI;SACxD,aAAa,EAAE;SACf,6BAA6B,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;IAElD,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,IAAI;SACpD,aAAa,EAAE;SACf,6BAA6B,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;IAEhD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;IACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,CAAC;IAE/C,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC;IAElC,MAAM,OAAO,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAEzC,MAAM,uBAAuB,GAAG,WAAW,CAAC,uBAAuB,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChG,MAAM,6BAA6B,GAAG,WAAW,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC;IAClF,MAAM,eAAe,GAAG,WAAW,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;IACjE,MAAM,UAAU,GAAG,WAAW,CAAC,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAChE,MAAM,KAAK,GAAG,WAAW,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAE1D,MAAM,sBAAsB,GAAG,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5D,MAAM,0BAA0B,GAAG,SAAS,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACpE,MAAM,6BAA6B,GAAG,SAAS,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAC1E,MAAM,iCAAiC,GAAG,SAAS,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;IAClF,MAAM,kBAAkB,GAAG,SAAS,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;IACjE,MAAM,gBAAgB,GAAG,SAAS,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAE7D,OAAO;QACL,IAAI,EAAE,IAAI;QACV,KAAK,EAAE;YACL,KAAK,EAAE;gBACL,IAAI,EAAE,SAAS;gBACf,SAAS,EAAE,cAAc;aAC1B;YACD,GAAG,EAAE;gBACH,IAAI,EAAE,OAAO;gBACb,SAAS,EAAE,YAAY;aACxB;YACD,MAAM,EAAE,UAAU;SACnB;QACD,QAAQ;QACR,iBAAiB,EAAE;YACjB,sBAAsB;YACtB,0BAA0B;YAC1B,6BAA6B;YAC7B,iCAAiC;YACjC,kBAAkB;YAClB,gBAAgB;SACjB;QACD,aAAa,EAAE;YACb,uBAAuB;YACvB,6BAA6B;YAC7B,eAAe;YACf,UAAU;YACV,KAAK;SACN;QACD,MAAM;QACN,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;KACtE,CAAC;AACJ,CAAC"}

package/dist/ast/prisma/is-prisma-expression.d.ts

@@ -0,0 +1,5 @@
+import type * as TS from 'typescript';
+import { PrismaNodeExpression } from '../../types/prisma.types.js';
+import { AstUtils } from '../utils/create-ast-utils.js';
+export declare function isPrismaExpression(node: TS.Node, program: TS.Program, { node: nodeUtils, prisma: prismaUtils }: AstUtils): node is PrismaNodeExpression;
+//# sourceMappingURL=is-prisma-expression.d.ts.map

package/dist/ast/prisma/is-prisma-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-prisma-expression.d.ts","sourceRoot":"","sources":["../../../src/ast/prisma/is-prisma-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAKxD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,OAAO,EAAE,EAAE,CAAC,OAAO,EACnB,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,QAAQ,GACjD,IAAI,IAAI,oBAAoB,CAgE9B"}

package/dist/ast/prisma/is-prisma-expression.js

@@ -0,0 +1,52 @@
+import { removeQuotes } from './utils/remove-quotes.js';
+import { PRISMA_METHODS } from '../../constants/prisma-methods.constants.js';
+export function isPrismaExpression(node, program, { node: nodeUtils, prisma: prismaUtils }) {
+    if (nodeUtils.isCallExpression(node)) {
+        const isPropertyAccess = nodeUtils.isPropertyAccessExpression(node.expression);
+        const isElementAccess = nodeUtils.isElementAccessExpression(node.expression);
+        if (isPropertyAccess) {
+            const methodNode = node.expression.name;
+            const method = methodNode.text;
+            if (!PRISMA_METHODS.has(method)) {
+                return false;
+            }
+            const checker = program.getTypeChecker();
+            const symbol = checker.getSymbolAtLocation(methodNode);
+            const declarations = symbol?.getDeclarations() ?? [];
+            const isGeneratedPrismaMethod = prismaUtils.isGeneratedPrismaFile(declarations);
+            if (isGeneratedPrismaMethod)
+                return true;
+        }
+        if (isElementAccess) {
+            const methodNode = node.expression.argumentExpression;
+            const method = removeQuotes(methodNode.getText());
+            if (!PRISMA_METHODS.has(method)) {
+                return false;
+            }
+            const checker = program.getTypeChecker();
+            const symbol = checker.getSymbolAtLocation(methodNode);
+            const declarations = symbol?.getDeclarations() ?? [];
+            const isGeneratedPrismaMethod = prismaUtils.isGeneratedPrismaFile(declarations);
+            if (isGeneratedPrismaMethod)
+                return true;
+        }
+    }
+    if (nodeUtils.isNewExpression(node)) {
+        const checker = program.getTypeChecker();
+        const symbolLocation = nodeUtils.isPropertyAccessExpression(node.expression)
+            ? node.expression.name
+            : node.expression;
+        const symbol = checker.getSymbolAtLocation(symbolLocation);
+        if (!symbol)
+            return false;
+        const resolvedSymbol = nodeUtils.resolveAliasedSymbol(symbol, checker);
+        if (resolvedSymbol.getName() !== 'PrismaClient')
+            return false;
+        const declarations = resolvedSymbol.getDeclarations() ?? [];
+        const isGeneratedPrismaClient = prismaUtils.isGeneratedPrismaFile(declarations);
+        if (isGeneratedPrismaClient)
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=is-prisma-expression.js.map

package/dist/ast/prisma/is-prisma-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-prisma-expression.js","sourceRoot":"","sources":["../../../src/ast/prisma/is-prisma-expression.ts"],"names":[],"mappings":"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"}

package/dist/ast/prisma/utils/define-method.d.ts

@@ -0,0 +1,4 @@
+import { PrismaNodeExpression } from '../../../types/prisma.types.js';
+import { AstUtils } from '../../utils/create-ast-utils.js';
+export declare function defineMethod(node: PrismaNodeExpression, nodeUtils: AstUtils['node']): string;
+//# sourceMappingURL=define-method.d.ts.map

package/dist/ast/prisma/utils/define-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-method.d.ts","sourceRoot":"","sources":["../../../../src/ast/prisma/utils/define-method.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEtE,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAkB3D,wBAAgB,YAAY,CAAC,IAAI,EAAE,oBAAoB,EAAE,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,UAUnF"}

package/dist/ast/prisma/utils/define-method.js

@@ -0,0 +1,18 @@
+import { removeQuotes } from './remove-quotes.js';
+function isPropertyAccess(expression, nodeUtils) {
+    return nodeUtils.isPropertyAccessExpression(expression);
+}
+function isElementAccess(expression, nodeUtils) {
+    return nodeUtils.isElementAccessExpression(expression);
+}
+export function defineMethod(node, nodeUtils) {
+    const isNewExpression = nodeUtils.isNewExpression(node);
+    if (isNewExpression)
+        return 'PrismaClient';
+    if (isPropertyAccess(node.expression, nodeUtils))
+        return node.expression.name.text;
+    if (isElementAccess(node.expression, nodeUtils))
+        return removeQuotes(node.expression.argumentExpression.getText());
+    return 'unknown';
+}
+//# sourceMappingURL=define-method.js.map

package/dist/ast/prisma/utils/define-method.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-method.js","sourceRoot":"","sources":["../../../../src/ast/prisma/utils/define-method.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,SAAS,gBAAgB,CACvB,UAAoE,EACpE,SAA2B;IAE3B,OAAO,SAAS,CAAC,0BAA0B,CAAC,UAAU,CAAC,CAAC;AAC1D,CAAC;AAED,SAAS,eAAe,CACtB,UAAoE,EACpE,SAA2B;IAE3B,OAAO,SAAS,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,IAA0B,EAAE,SAA2B;IAClF,MAAM,eAAe,GAAG,SAAS,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAExD,IAAI,eAAe;QAAE,OAAO,cAAc,CAAC;IAE3C,IAAI,gBAAgB,CAAC,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;IACnF,IAAI,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC;QAC7C,OAAO,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC,OAAO,EAAE,CAAC,CAAC;IAEpE,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/ast/prisma/utils/remove-quotes.d.ts

@@ -0,0 +1,2 @@
+export declare function removeQuotes(value: string): string;
+//# sourceMappingURL=remove-quotes.d.ts.map

package/dist/ast/prisma/utils/remove-quotes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-quotes.d.ts","sourceRoot":"","sources":["../../../../src/ast/prisma/utils/remove-quotes.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUlD"}

package/dist/ast/prisma/utils/remove-quotes.js

@@ -0,0 +1,9 @@
+export function removeQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'")) ||
+        (value.startsWith('`') && value.endsWith('`'))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+//# sourceMappingURL=remove-quotes.js.map

package/dist/ast/prisma/utils/remove-quotes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-quotes.js","sourceRoot":"","sources":["../../../../src/ast/prisma/utils/remove-quotes.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,IACE,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC9C,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC9C,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAC9C,CAAC;QACD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5B,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/ast/utils/create-ast-utils.d.ts

@@ -0,0 +1,30 @@
+import type * as TS from 'typescript';
+export declare function createAstUtils(ts: typeof TS, checker: TS.TypeChecker): {
+    node: {
+        isCallExpression: (node: TS.Node) => node is TS.CallExpression;
+        isPropertyAccessExpression: (node: TS.Node) => node is TS.PropertyAccessExpression;
+        isElementAccessExpression: (node: TS.Node) => node is TS.ElementAccessExpression;
+        isNewExpression: (node: TS.Node) => node is TS.NewExpression;
+        getPropertyName: (name: TS.PropertyName) => string;
+        resolveAliasedSymbol: (symbol: TS.Symbol, checker: TS.TypeChecker) => TS.Symbol;
+        getParentFunctionName: (node: TS.Node) => string | null;
+        getParentMethodName: (node: TS.Node) => string | null;
+        isInsideLoop: (node: TS.Node) => boolean;
+        isInsideFunction: (node: TS.Node) => boolean;
+        isInsideClassMethod: (node: TS.Node) => boolean;
+        isInsideAwaitExpression: (node: TS.Node) => boolean;
+        parseArgument: (node: TS.CallExpression | TS.NewExpression, index?: number) => import("../../index.js").ParsedValue | undefined;
+        parseObject: (node: TS.ObjectLiteralExpression) => import("../../index.js").ParsedValue<import("../../types/ast.types.js").AstObject>;
+        parseValue: (node: TS.Expression, checker: TS.TypeChecker) => import("../../index.js").ParsedValue;
+    };
+    prisma: {
+        resolveTransactionType: (node: TS.Node) => import("../../types/prisma.types.js").TransactionType | null;
+        resolveClientType: (node: TS.Node, checker: TS.TypeChecker) => import("../../types/prisma.types.js").ClientType;
+        isGeneratedPrismaFile: (declarations: TS.Declaration[]) => boolean;
+        isFloatingPrismaPromise: (node: TS.Node, parent: TS.Node, checker: TS.TypeChecker) => boolean;
+        isInsidePrismaTransaction: (node: TS.Node) => boolean;
+        resolveModelName: (node: import("../../types/prisma.types.js").PrismaNodeExpression, checker: TS.TypeChecker) => string | null;
+    };
+};
+export type AstUtils = ReturnType<typeof createAstUtils>;
+//# sourceMappingURL=create-ast-utils.d.ts.map

package/dist/ast/utils/create-ast-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-ast-utils.d.ts","sourceRoot":"","sources":["../../../src/ast/utils/create-ast-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAKtC,wBAAgB,cAAc,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW;IAEjE,IAAI;;;;;;;;;;;;;;;;;IACJ,MAAM;;;;;;;;EAET;AAED,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/ast/utils/create-ast-utils.js

@@ -0,0 +1,9 @@
+import { createNodeUtils } from './create-node-utils.js';
+import { createPrismaUtils } from './create-prisma-utils.js';
+export function createAstUtils(ts, checker) {
+    return {
+        node: createNodeUtils(ts, checker),
+        prisma: createPrismaUtils(ts),
+    };
+}
+//# sourceMappingURL=create-ast-utils.js.map

package/dist/ast/utils/create-ast-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-ast-utils.js","sourceRoot":"","sources":["../../../src/ast/utils/create-ast-utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,MAAM,UAAU,cAAc,CAAC,EAAa,EAAE,OAAuB;IACnE,OAAO;QACL,IAAI,EAAE,eAAe,CAAC,EAAE,EAAE,OAAO,CAAC;QAClC,MAAM,EAAE,iBAAiB,CAAC,EAAE,CAAC;KAC9B,CAAC;AACJ,CAAC"}

package/dist/ast/utils/create-node-utils.d.ts

@@ -0,0 +1,21 @@
+import type * as TS from 'typescript';
+import { AstObject, ParsedValue } from '../../types/ast.types.js';
+export declare function createNodeUtils(ts: typeof TS, checker: TS.TypeChecker): {
+    isCallExpression: (node: TS.Node) => node is TS.CallExpression;
+    isPropertyAccessExpression: (node: TS.Node) => node is TS.PropertyAccessExpression;
+    isElementAccessExpression: (node: TS.Node) => node is TS.ElementAccessExpression;
+    isNewExpression: (node: TS.Node) => node is TS.NewExpression;
+    getPropertyName: (name: TS.PropertyName) => string;
+    resolveAliasedSymbol: (symbol: TS.Symbol, checker: TS.TypeChecker) => TS.Symbol;
+    getParentFunctionName: (node: TS.Node) => string | null;
+    getParentMethodName: (node: TS.Node) => string | null;
+    isInsideLoop: (node: TS.Node) => boolean;
+    isInsideFunction: (node: TS.Node) => boolean;
+    isInsideClassMethod: (node: TS.Node) => boolean;
+    isInsideAwaitExpression: (node: TS.Node) => boolean;
+    parseArgument: (node: TS.CallExpression | TS.NewExpression, index?: number) => ParsedValue | undefined;
+    parseObject: (node: TS.ObjectLiteralExpression) => ParsedValue<AstObject>;
+    parseValue: (node: TS.Expression, checker: TS.TypeChecker) => ParsedValue;
+};
+export type NodeUtils = ReturnType<typeof createNodeUtils>;
+//# sourceMappingURL=create-node-utils.d.ts.map

package/dist/ast/utils/create-node-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-node-utils.d.ts","sourceRoot":"","sources":["../../../src/ast/utils/create-node-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,SAAS,EAAgB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIhF,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW;6BAGpC,EAAE,CAAC,IAAI;uCAIG,EAAE,CAAC,IAAI;sCAIR,EAAE,CAAC,IAAI;4BAIjB,EAAE,CAAC,IAAI;4BAIP,EAAE,CAAC,YAAY,KAAG,MAAM;mCAQjB,EAAE,CAAC,MAAM,WAAW,EAAE,CAAC,WAAW,KAAG,EAAE,CAAC,MAAM;kCAI/C,EAAE,CAAC,IAAI,KAAG,MAAM,GAAG,IAAI;gCAczB,EAAE,CAAC,IAAI,KAAG,MAAM,GAAG,IAAI;yBAc9B,EAAE,CAAC,IAAI,KAAG,OAAO;6BAmCb,EAAE,CAAC,IAAI,KAAG,OAAO;gCAiBd,EAAE,CAAC,IAAI,KAAG,OAAO;oCAiBb,EAAE,CAAC,IAAI,KAAG,OAAO;0BAehD,EAAE,CAAC,cAAc,GAAG,EAAE,CAAC,aAAa,qBAEzC,WAAW,GAAG,SAAS;wBAUC,EAAE,CAAC,uBAAuB,KAAG,WAAW,CAAC,SAAS,CAAC;uBAwKpD,EAAE,CAAC,UAAU,WAAW,EAAE,CAAC,WAAW,KAAG,WAAW;EAoG/E;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}