osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/typescript/mongoose_orm.py

@@ -0,0 +1,151 @@
+"""Mongoose ODM detector for TypeScript/JavaScript."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class MongooseORMDetector:
+    """Detects Mongoose ODM usage patterns in TypeScript/JavaScript files."""
+
+    name: str = "mongoose_orm"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    # mongoose.model('Name', schema)
+    _MODEL_RE = re.compile(r"mongoose\.model\s*\(\s*['\"](\w+)['\"]")
+    # new Schema({ or new mongoose.Schema({
+    _SCHEMA_RE = re.compile(r"(?:const|let|var)\s+(\w+)\s*=\s*new\s+(?:mongoose\.)?Schema\s*\(")
+    # mongoose.connect(
+    _CONNECT_RE = re.compile(r"mongoose\.connect\s*\(")
+    # Model query operations
+    _QUERY_RE = re.compile(
+        r"(\w+)\.(find|findOne|findById|findOneAndUpdate|findOneAndDelete"
+        r"|create|insertMany|updateOne|updateMany|deleteOne|deleteMany"
+        r"|countDocuments|aggregate)\s*\("
+    )
+    # schema.virtual('name')
+    _VIRTUAL_RE = re.compile(r"(\w+)\.virtual\s*\(\s*['\"](\w+)['\"]")
+    # schema.pre('save', ...) / schema.post('save', ...)
+    _HOOK_RE = re.compile(r"(\w+)\.(pre|post)\s*\(\s*['\"](\w+)['\"]")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        seen_models: dict[str, str] = {}
+        schema_vars: set[str] = set()
+
+        # Detect mongoose.connect -> DATABASE_CONNECTION
+        for match in self._CONNECT_RE.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"mongoose:{ctx.file_path}:connection:{line}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.DATABASE_CONNECTION,
+                    label="mongoose.connect",
+                    fqn=f"{ctx.file_path}::mongoose.connect",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={"framework": "mongoose"},
+                )
+            )
+
+        # Detect new Schema({ ... }) -> ENTITY for schema definition
+        for match in self._SCHEMA_RE.finditer(text):
+            var_name = match.group(1)
+            schema_vars.add(var_name)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"mongoose:{ctx.file_path}:schema:{var_name}"
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENTITY,
+                    label=var_name,
+                    fqn=f"{ctx.file_path}::{var_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={"framework": "mongoose", "definition": "schema"},
+                )
+            )
+
+        # Detect mongoose.model('Name', schema) -> ENTITY
+        for match in self._MODEL_RE.finditer(text):
+            model_name = match.group(1)
+            line = text[: match.start()].count("\n") + 1
+            model_id = f"mongoose:{ctx.file_path}:model:{model_name}"
+            seen_models[model_name] = model_id
+            result.nodes.append(
+                GraphNode(
+                    id=model_id,
+                    kind=NodeKind.ENTITY,
+                    label=model_name,
+                    fqn=f"{ctx.file_path}::{model_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={"framework": "mongoose", "definition": "model"},
+                )
+            )
+
+        # Detect schema.virtual('name') -> property on schema
+        virtuals: list[str] = []
+        for match in self._VIRTUAL_RE.finditer(text):
+            var_name = match.group(1)
+            virtual_name = match.group(2)
+            if var_name in schema_vars:
+                virtuals.append(virtual_name)
+
+        # Attach virtuals to schema nodes
+        if virtuals:
+            for node in result.nodes:
+                if node.properties.get("definition") == "schema":
+                    node.properties["virtuals"] = virtuals
+
+        # Detect schema.pre/post hooks -> EVENT nodes
+        for match in self._HOOK_RE.finditer(text):
+            var_name = match.group(1)
+            hook_type = match.group(2)
+            event_name = match.group(3)
+            if var_name in schema_vars:
+                line = text[: match.start()].count("\n") + 1
+                event_id = f"mongoose:{ctx.file_path}:hook:{hook_type}:{event_name}:{line}"
+                result.nodes.append(
+                    GraphNode(
+                        id=event_id,
+                        kind=NodeKind.EVENT,
+                        label=f"{hook_type}:{event_name}",
+                        fqn=f"{ctx.file_path}::{hook_type}:{event_name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                        properties={
+                            "framework": "mongoose",
+                            "hook_type": hook_type,
+                            "event": event_name,
+                        },
+                    )
+                )
+
+        # Detect query operations -> QUERIES edges
+        for match in self._QUERY_RE.finditer(text):
+            model_name = match.group(1)
+            operation = match.group(2)
+            line = text[: match.start()].count("\n") + 1
+
+            target_id = seen_models.get(
+                model_name, f"mongoose:{ctx.file_path}:model:{model_name}"
+            )
+            result.edges.append(
+                GraphEdge(
+                    source=ctx.file_path,
+                    target=target_id,
+                    kind=EdgeKind.QUERIES,
+                    label=f"{model_name}.{operation}",
+                    properties={"operation": operation, "line": line},
+                )
+            )
+
+        return result

osscodeiq/detectors/typescript/nestjs_controllers.py

@@ -0,0 +1,99 @@
+"""NestJS controller detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class NestJSControllerDetector:
+    """Detects NestJS controller decorators (@Controller, @Get, @Post, etc.)."""
+
+    name: str = "typescript.nestjs_controllers"
+    supported_languages: tuple[str, ...] = ("typescript",)
+
+    # @Controller('users') or @Controller('/api/users')
+    _CONTROLLER_PATTERN = re.compile(
+        r"@Controller\(\s*['\"`]?([^'\"`)\s]*)['\"`]?\s*\)\s*\n\s*(?:export\s+)?class\s+(\w+)"
+    )
+
+    # @Get('/:id'), @Post(), @Put('/:id'), @Delete('/:id'), @Patch('/:id')
+    _ROUTE_PATTERN = re.compile(
+        r"@(Get|Post|Put|Delete|Patch|Options|Head)\(\s*['\"`]?([^'\"`)\s]*)['\"`]?\s*\)"
+        r"\s*\n\s*(?:async\s+)?(\w+)"
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Find controllers and their base paths
+        controllers: dict[str, str] = {}
+        for match in self._CONTROLLER_PATTERN.finditer(text):
+            base_path = match.group(1) or ""
+            class_name = match.group(2)
+            controllers[class_name] = base_path
+            line = text[:match.start()].count("\n") + 1
+
+            class_id = f"class:{ctx.file_path}::{class_name}"
+            result.nodes.append(GraphNode(
+                id=class_id,
+                kind=NodeKind.CLASS,
+                label=class_name,
+                fqn=f"{ctx.file_path}::{class_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["@Controller"],
+                properties={"framework": "nestjs", "stereotype": "controller"},
+            ))
+
+        # Build sorted list of (line, class_name, base_path)
+        controller_ranges = []
+        for match in self._CONTROLLER_PATTERN.finditer(text):
+            ctrl_line = text[:match.start()].count("\n") + 1
+            controller_ranges.append((ctrl_line, match.group(2), match.group(1) or ""))
+
+        # For each route, find the controller it belongs to
+        for match in self._ROUTE_PATTERN.finditer(text):
+            route_line = text[:match.start()].count("\n") + 1
+            # Find the last controller that starts before this route
+            enclosing_ctrl = ("", "")  # (class_name, base_path)
+            for ctrl_line, ctrl_name, ctrl_path in controller_ranges:
+                if ctrl_line <= route_line:
+                    enclosing_ctrl = (ctrl_name, ctrl_path)
+            current_class, base_path = enclosing_ctrl
+
+            method = match.group(1).upper()
+            path = match.group(2) or ""
+            func_name = match.group(3)
+
+            full_path = f"/{base_path}/{path}".replace("//", "/").rstrip("/") or "/"
+
+            node_id = f"endpoint:{ctx.module_name or ''}:{method}:{full_path}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.ENDPOINT,
+                label=f"{method} {full_path}",
+                fqn=f"{ctx.file_path}::{func_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=route_line),
+                properties={
+                    "protocol": "REST",
+                    "http_method": method,
+                    "path_pattern": full_path,
+                    "framework": "nestjs",
+                },
+            ))
+
+            if current_class:
+                class_id = f"class:{ctx.file_path}::{current_class}"
+                result.edges.append(GraphEdge(
+                    source=class_id,
+                    target=node_id,
+                    kind=EdgeKind.EXPOSES,
+                ))
+
+        return result

osscodeiq/detectors/typescript/nestjs_guards.py

@@ -0,0 +1,138 @@
+"""NestJS guard and role-based access control detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import GraphNode, NodeKind, SourceLocation
+
+
+class NestJSGuardsDetector:
+    """Detects NestJS guard decorators, role decorators, and canActivate implementations."""
+
+    name: str = "typescript.nestjs_guards"
+    supported_languages: tuple[str, ...] = ("typescript",)
+
+    # @UseGuards(JwtAuthGuard) or @UseGuards(JwtAuthGuard, RolesGuard)
+    _USE_GUARDS_PATTERN = re.compile(
+        r"@UseGuards\(\s*([^)]+)\)"
+    )
+
+    # @Roles('admin', 'user') or @Roles("admin", "user")
+    _ROLES_PATTERN = re.compile(
+        r"@Roles\(\s*([^)]+)\)"
+    )
+
+    # canActivate(context): boolean/Promise<boolean>/Observable<boolean>
+    _CAN_ACTIVATE_PATTERN = re.compile(
+        r"(?:async\s+)?canActivate\s*\("
+    )
+
+    # AuthGuard('jwt') or AuthGuard("local")
+    _AUTH_GUARD_PATTERN = re.compile(
+        r"AuthGuard\(\s*['\"](\w+)['\"]\s*\)"
+    )
+
+    @staticmethod
+    def _parse_roles(raw: str) -> list[str]:
+        """Extract role strings from a @Roles(...) argument list."""
+        roles: list[str] = []
+        for match in re.finditer(r"""['"]([\w\-]+)['"]""", raw):
+            roles.append(match.group(1))
+        return roles
+
+    @staticmethod
+    def _parse_guard_names(raw: str) -> list[str]:
+        """Extract guard class names from a @UseGuards(...) argument list."""
+        names: list[str] = []
+        for token in raw.split(","):
+            token = token.strip()
+            if token and re.match(r"^\w+$", token):
+                names.append(token)
+        return names
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Detect @UseGuards(...)
+        for match in self._USE_GUARDS_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            guard_names = self._parse_guard_names(match.group(1))
+            for guard_name in guard_names:
+                node_id = f"auth:{ctx.file_path}:UseGuards({guard_name}):{line}"
+                result.nodes.append(GraphNode(
+                    id=node_id,
+                    kind=NodeKind.GUARD,
+                    label=f"UseGuards({guard_name})",
+                    fqn=f"{ctx.file_path}::UseGuards({guard_name})",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    annotations=["@UseGuards"],
+                    properties={
+                        "auth_type": "nestjs_guard",
+                        "guard_name": guard_name,
+                        "roles": [],
+                    },
+                ))
+
+        # Detect @Roles(...)
+        for match in self._ROLES_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            roles = self._parse_roles(match.group(1))
+            node_id = f"auth:{ctx.file_path}:Roles:{line}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.GUARD,
+                label=f"Roles({', '.join(roles)})",
+                fqn=f"{ctx.file_path}::Roles",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["@Roles"],
+                properties={
+                    "auth_type": "nestjs_guard",
+                    "roles": roles,
+                },
+            ))
+
+        # Detect canActivate() implementations
+        for match in self._CAN_ACTIVATE_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"auth:{ctx.file_path}:canActivate:{line}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.GUARD,
+                label="canActivate()",
+                fqn=f"{ctx.file_path}::canActivate",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "auth_type": "nestjs_guard",
+                    "guard_impl": "canActivate",
+                    "roles": [],
+                },
+            ))
+
+        # Detect AuthGuard('jwt') etc.
+        for match in self._AUTH_GUARD_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            strategy = match.group(1)
+            node_id = f"auth:{ctx.file_path}:AuthGuard({strategy}):{line}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.GUARD,
+                label=f"AuthGuard('{strategy}')",
+                fqn=f"{ctx.file_path}::AuthGuard({strategy})",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["AuthGuard"],
+                properties={
+                    "auth_type": "nestjs_guard",
+                    "strategy": strategy,
+                    "roles": [],
+                },
+            ))
+
+        return result

osscodeiq/detectors/typescript/passport_jwt.py

@@ -0,0 +1,133 @@
+"""Passport.js and JWT authentication detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import GraphNode, NodeKind, SourceLocation
+
+
+class PassportJwtDetector:
+    """Detects Passport.js strategy registrations, authenticate calls, and JWT verification."""
+
+    name: str = "typescript.passport_jwt"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    # passport.use(new JwtStrategy(...)) or passport.use(new LocalStrategy(...))
+    _PASSPORT_USE_PATTERN = re.compile(
+        r"passport\.use\(\s*new\s+(\w+Strategy)\s*\("
+    )
+
+    # passport.authenticate('jwt') or passport.authenticate("local", ...)
+    _PASSPORT_AUTH_PATTERN = re.compile(
+        r"passport\.authenticate\(\s*['\"](\w+)['\"]"
+    )
+
+    # jwt.verify(token, secret) or jwt.verify(token, secret, options)
+    _JWT_VERIFY_PATTERN = re.compile(
+        r"jwt\.verify\s*\("
+    )
+
+    # require('express-jwt') or require("express-jwt")
+    _REQUIRE_EXPRESS_JWT_PATTERN = re.compile(
+        r"""require\(\s*['"]express-jwt['"]\s*\)"""
+    )
+
+    # import { expressjwt } from 'express-jwt' (and variants)
+    _IMPORT_EXPRESS_JWT_PATTERN = re.compile(
+        r"""import\s+\{[^}]*\bexpressjwt\b[^}]*\}\s+from\s+['"]express-jwt['"]"""
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Detect passport.use(new XxxStrategy(...))
+        for match in self._PASSPORT_USE_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            strategy_name = match.group(1)
+            node_id = f"auth:{ctx.file_path}:passport.use({strategy_name}):{line}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.GUARD,
+                label=f"passport.use({strategy_name})",
+                fqn=f"{ctx.file_path}::passport.use({strategy_name})",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "auth_type": "passport",
+                    "strategy": strategy_name,
+                },
+            ))
+
+        # Detect passport.authenticate('xxx')
+        for match in self._PASSPORT_AUTH_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            strategy = match.group(1)
+            node_id = f"auth:{ctx.file_path}:passport.authenticate({strategy}):{line}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.MIDDLEWARE,
+                label=f"passport.authenticate('{strategy}')",
+                fqn=f"{ctx.file_path}::passport.authenticate({strategy})",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "auth_type": "jwt",
+                    "strategy": strategy,
+                },
+            ))
+
+        # Detect jwt.verify(...)
+        for match in self._JWT_VERIFY_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"auth:{ctx.file_path}:jwt.verify:{line}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.MIDDLEWARE,
+                label="jwt.verify()",
+                fqn=f"{ctx.file_path}::jwt.verify",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "auth_type": "jwt",
+                },
+            ))
+
+        # Detect require('express-jwt')
+        for match in self._REQUIRE_EXPRESS_JWT_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"auth:{ctx.file_path}:require(express-jwt):{line}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.MIDDLEWARE,
+                label="require('express-jwt')",
+                fqn=f"{ctx.file_path}::require(express-jwt)",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "auth_type": "jwt",
+                    "library": "express-jwt",
+                },
+            ))
+
+        # Detect import { expressjwt } from 'express-jwt'
+        for match in self._IMPORT_EXPRESS_JWT_PATTERN.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"auth:{ctx.file_path}:import(expressjwt):{line}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.MIDDLEWARE,
+                label="import { expressjwt }",
+                fqn=f"{ctx.file_path}::import(expressjwt)",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "auth_type": "jwt",
+                    "library": "express-jwt",
+                },
+            ))
+
+        return result

osscodeiq/detectors/typescript/prisma_orm.py

@@ -0,0 +1,96 @@
+"""Prisma ORM detector for TypeScript/JavaScript."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class PrismaORMDetector:
+    """Detects Prisma ORM usage patterns in TypeScript/JavaScript files."""
+
+    name: str = "prisma_orm"
+    supported_languages: tuple[str, ...] = ("typescript", "javascript")
+
+    _PRISMA_OP_RE = re.compile(
+        r"prisma\.(\w+)\.(findMany|findFirst|findUnique|create|update|delete|upsert|count|aggregate|groupBy)\s*\("
+    )
+    _PRISMA_CLIENT_RE = re.compile(r"new\s+PrismaClient\s*\(|PrismaClient\s*\(")
+    _PRISMA_IMPORT_RE = re.compile(r"""(?:import|require)\s*\(?[^)]*['"]@prisma/client['"]""")
+    _PRISMA_TRANSACTION_RE = re.compile(r"prisma\.\$transaction\s*\(")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Detect PrismaClient instantiation -> DATABASE_CONNECTION
+        for match in self._PRISMA_CLIENT_RE.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"prisma:{ctx.file_path}:client:{line}"
+            props: dict[str, object] = {"framework": "prisma"}
+            # Check for $transaction usage
+            if self._PRISMA_TRANSACTION_RE.search(text):
+                props["transaction"] = True
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.DATABASE_CONNECTION,
+                    label="PrismaClient",
+                    fqn=f"{ctx.file_path}::PrismaClient",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties=props,
+                )
+            )
+
+        # Detect @prisma/client imports -> IMPORTS edge
+        for match in self._PRISMA_IMPORT_RE.finditer(text):
+            line = text[: match.start()].count("\n") + 1
+            result.edges.append(
+                GraphEdge(
+                    source=ctx.file_path,
+                    target="@prisma/client",
+                    kind=EdgeKind.IMPORTS,
+                    label="import @prisma/client",
+                    properties={"line": line},
+                )
+            )
+
+        # Detect prisma model operations -> ENTITY nodes + QUERIES edges
+        seen_models: dict[str, str] = {}
+        for match in self._PRISMA_OP_RE.finditer(text):
+            model_name = match.group(1)
+            operation = match.group(2)
+            line = text[: match.start()].count("\n") + 1
+
+            # Create ENTITY node for each unique model
+            if model_name not in seen_models:
+                model_id = f"prisma:{ctx.file_path}:model:{model_name}"
+                seen_models[model_name] = model_id
+                result.nodes.append(
+                    GraphNode(
+                        id=model_id,
+                        kind=NodeKind.ENTITY,
+                        label=model_name,
+                        fqn=f"{ctx.file_path}::{model_name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                        properties={"framework": "prisma"},
+                    )
+                )
+
+            # QUERIES edge from file to model
+            result.edges.append(
+                GraphEdge(
+                    source=ctx.file_path,
+                    target=seen_models[model_name],
+                    kind=EdgeKind.QUERIES,
+                    label=f"{model_name}.{operation}",
+                    properties={"operation": operation, "line": line},
+                )
+            )
+
+        return result