prisma-safe-delete 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2025-02-07
+
+### Added
+- Initial release
+- Type-safe soft deletion wrapper for Prisma 7
+- Automatic filter injection on all read operations
+- Deep relation filtering for `include`, `select`, `_count`, and relation filters (`some`/`every`/`none`)
+- Cascade soft-delete following `onDelete: Cascade` relations
+- Unique string field mangling to free values for reuse
+- Transaction support with wrapped clients
+- Compound primary key support
+- Escape hatches: `$prisma`, `$includingDeleted`, `$onlyDeleted`
+- `hardDelete` and `hardDeleteMany` methods
+- `softDelete` and `softDeleteMany` methods
+- Support for both `deleted_at` and `deletedAt` field names

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 EddieRydell
+
+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

@@ -0,0 +1,436 @@
+# prisma-safe-delete
+
+[![npm version](https://img.shields.io/npm/v/prisma-safe-delete.svg)](https://www.npmjs.com/package/prisma-safe-delete)
+[![npm downloads](https://img.shields.io/npm/dm/prisma-safe-delete.svg)](https://www.npmjs.com/package/prisma-safe-delete)
+[![CI](https://github.com/EddieRydell/prisma-safe-delete/actions/workflows/ci.yml/badge.svg)](https://github.com/EddieRydell/prisma-safe-delete/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+
+A Prisma generator that creates a type-safe wrapper for soft deletion with automatic cascade support. Designed to be a drop-in replacement that you configure once and never think about again.
+
+## Why This Library?
+
+Soft deletion is a common pattern where records are marked as deleted (typically with a timestamp) rather than being permanently removed. This preserves data for auditing, recovery, and maintaining referential integrity.
+
+**The problem:** Implementing soft deletion correctly is tedious and error-prone. You need to remember to filter out deleted records in every query, handle cascading deletes manually, and deal with unique constraint conflicts when "deleted" records still occupy unique values.
+
+**prisma-safe-delete solves this by:**
+- Automatically filtering deleted records from all read operations
+- Cascading soft-deletes through your relation tree (following `onDelete: Cascade`)
+- Mangling unique string fields to free them for reuse
+- Providing escape hatches when you need to access deleted data
+
+## Features
+
+- **Automatic filter injection**: All read operations automatically exclude soft-deleted records
+- **Deep relation filtering**: Filters applied to `include`, `select`, `_count`, and relation filters (`some`/`every`/`none`)
+- **Cascade soft-delete**: Automatically cascades based on `onDelete: Cascade` relations
+- **Unique constraint handling**: Automatically mangles unique string fields to free up values for reuse
+- **Transaction support**: Interactive transactions receive wrapped clients with filtering
+- **Compound key support**: Full support for compound primary keys and foreign keys
+- **Escape hatches**: Access raw client, query deleted records, or hard delete when needed
+
+## Installation
+
+```bash
+npm install prisma-safe-delete
+# or
+pnpm add prisma-safe-delete
+# or
+yarn add prisma-safe-delete
+```
+
+## Quick Start
+
+### 1. Add the generator to your Prisma schema
+
+```prisma
+generator client {
+  provider = "prisma-client"
+  output   = "./generated/client"
+}
+
+generator softDelete {
+  provider = "prisma-safe-delete"
+  output   = "./generated/soft-delete"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+```
+
+### 2. Add `deleted_at` to soft-deletable models
+
+```prisma
+model User {
+  id         String    @id @default(cuid())
+  email      String    @unique
+  name       String?
+  posts      Post[]
+  deleted_at DateTime?  // Makes this model soft-deletable
+}
+
+model Post {
+  id         String    @id @default(cuid())
+  title      String
+  authorId   String
+  author     User      @relation(fields: [authorId], references: [id], onDelete: Cascade)
+  comments   Comment[]
+  deleted_at DateTime?
+}
+
+model Comment {
+  id         String    @id @default(cuid())
+  content    String
+  postId     String
+  post       Post      @relation(fields: [postId], references: [id], onDelete: Cascade)
+  deleted_at DateTime?
+}
+```
+
+### 3. Generate and use
+
+```bash
+npx prisma generate
+```
+
+```typescript
+import { PrismaClient } from './generated/client';
+import { PrismaPg } from '@prisma/adapter-pg';
+import { Pool } from 'pg';
+import { wrapPrismaClient } from './generated/soft-delete';
+
+// Prisma 7 requires an adapter
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const adapter = new PrismaPg(pool);
+
+const prisma = new PrismaClient({ adapter });
+const safePrisma = wrapPrismaClient(prisma);
+
+// All queries automatically filter out soft-deleted records
+const users = await safePrisma.user.findMany();
+
+// Soft delete with automatic cascade
+await safePrisma.user.softDelete({ where: { id: 'user-1' } });
+// ^ This soft-deletes the user AND all their posts AND all comments on those posts
+```
+
+## API Reference
+
+### Read Operations (Auto-filtered)
+
+All read operations automatically inject `deleted_at: null` filters:
+
+```typescript
+// These all exclude soft-deleted records automatically
+await safePrisma.user.findMany();
+await safePrisma.user.findFirst({ where: { name: 'John' } });
+await safePrisma.user.findUnique({ where: { id: 'user-1' } });
+await safePrisma.user.findFirstOrThrow({ where: { email: 'john@example.com' } });
+await safePrisma.user.findUniqueOrThrow({ where: { id: 'user-1' } });
+await safePrisma.user.count();
+await safePrisma.user.aggregate({ _count: true });
+await safePrisma.user.groupBy({ by: ['name'], _count: true });
+```
+
+### Relation Queries (Auto-filtered)
+
+Filters are automatically injected into relation queries:
+
+```typescript
+// Posts in include are filtered
+const user = await safePrisma.user.findUnique({
+  where: { id: 'user-1' },
+  include: { posts: true }  // Only returns non-deleted posts
+});
+
+// Nested relations are filtered too
+const user = await safePrisma.user.findUnique({
+  where: { id: 'user-1' },
+  include: {
+    posts: {
+      include: { comments: true }  // Only non-deleted comments
+    }
+  }
+});
+
+// select works the same way
+const user = await safePrisma.user.findUnique({
+  where: { id: 'user-1' },
+  select: {
+    email: true,
+    posts: { select: { title: true } }  // Only non-deleted posts
+  }
+});
+
+// _count is filtered
+const user = await safePrisma.user.findUnique({
+  where: { id: 'user-1' },
+  include: {
+    _count: { select: { posts: true } }  // Counts only non-deleted posts
+  }
+});
+```
+
+### Relation Filters (Auto-filtered)
+
+The `some`, `every`, and `none` relation filters exclude soft-deleted records:
+
+```typescript
+// Find users who have at least one active post
+const users = await safePrisma.user.findMany({
+  where: {
+    posts: { some: { title: { contains: 'hello' } } }  // Ignores deleted posts
+  }
+});
+
+// Find users where all their posts are published
+const users = await safePrisma.user.findMany({
+  where: {
+    posts: { every: { published: true } }  // Only considers non-deleted posts
+  }
+});
+```
+
+### Write Operations
+
+```typescript
+// Standard write operations pass through unchanged
+await safePrisma.user.create({ data: { email: 'new@example.com' } });
+await safePrisma.user.createMany({ data: [...] });
+await safePrisma.user.update({ where: { id: 'user-1' }, data: { name: 'Jane' } });
+await safePrisma.user.updateMany({ where: { ... }, data: { ... } });
+await safePrisma.user.upsert({ where: { ... }, create: { ... }, update: { ... } });
+```
+
+### Soft Delete
+
+```typescript
+// Soft delete a single record (with cascade)
+await safePrisma.user.softDelete({ where: { id: 'user-1' } });
+
+// Soft delete multiple records (with cascade)
+const result = await safePrisma.user.softDeleteMany({ where: { name: 'Test' } });
+console.log(result.count); // Number of records soft-deleted
+```
+
+### Hard Delete (Escape Hatch)
+
+```typescript
+// Permanently delete when needed
+await safePrisma.user.hardDelete({ where: { id: 'user-1' } });
+await safePrisma.user.hardDeleteMany({ where: { createdAt: { lt: oldDate } } });
+```
+
+### Escape Hatches
+
+```typescript
+// Access the raw Prisma client (no filtering)
+const allUsers = await safePrisma.$prisma.user.findMany();
+
+// Query including soft-deleted records
+const allUsers = await safePrisma.$includingDeleted.user.findMany();
+
+// Query only soft-deleted records
+const deletedUsers = await safePrisma.$onlyDeleted.user.findMany();
+```
+
+### Transactions
+
+Interactive transactions receive wrapped clients with filtering:
+
+```typescript
+const result = await safePrisma.$transaction(async (tx) => {
+  // tx has the same filtering as safePrisma
+  const users = await tx.user.findMany();  // Excludes deleted
+  const posts = await tx.post.findMany();  // Excludes deleted
+  return { users, posts };
+});
+```
+
+## Cascade Behavior
+
+Soft-delete cascades follow `onDelete: Cascade` relations defined in your schema:
+
+```prisma
+model User {
+  id         String    @id
+  posts      Post[]
+  profile    Profile?
+  deleted_at DateTime?
+}
+
+model Post {
+  id         String    @id
+  author     User      @relation(fields: [authorId], references: [id], onDelete: Cascade)
+  authorId   String
+  comments   Comment[]
+  deleted_at DateTime?
+}
+
+model Comment {
+  id         String    @id
+  post       Post      @relation(fields: [postId], references: [id], onDelete: Cascade)
+  postId     String
+  deleted_at DateTime?
+}
+```
+
+```typescript
+await safePrisma.user.softDelete({ where: { id: 'user-1' } });
+// Soft-deletes:
+// 1. The user
+// 2. All their posts
+// 3. All comments on those posts
+// All with the same timestamp (transactional)
+```
+
+### Cascade Rules
+
+- Only follows `onDelete: Cascade` relations
+- Only soft-deletes children that have a `deleted_at` field
+- Children without `deleted_at` are left unchanged
+- All cascaded records get the same `deleted_at` timestamp
+- Entire operation is transactional (all-or-nothing)
+
+## Unique Constraint Handling
+
+When you soft-delete a record with unique string fields, the values are automatically mangled to free them up for reuse:
+
+```typescript
+// Before soft delete
+{ id: 'user-1', email: 'john@example.com', deleted_at: null }
+
+// After soft delete
+{ id: 'user-1', email: 'john@example.com__deleted_user-1', deleted_at: '2024-...' }
+
+// Now you can create a new user with the same email
+await safePrisma.user.create({ data: { email: 'john@example.com' } });  // Works!
+```
+
+### Mangling Rules
+
+- Only **string** fields with `@unique` or `@@unique` are mangled
+- Suffix format: `__deleted_{primaryKey}`
+- For compound PKs: `__deleted_{pk1}_{pk2}` (sorted alphabetically)
+- NULL values are not mangled (already allow duplicates)
+- Mangling is idempotent (won't double-mangle)
+- Fails with clear error if mangled value would exceed max string length
+
+### Non-String Unique Fields
+
+For non-string unique fields (Int, UUID, etc.), use a **partial unique index** in your database:
+
+```sql
+-- PostgreSQL
+CREATE UNIQUE INDEX user_employee_id_active ON "User"(employee_id) WHERE deleted_at IS NULL;
+
+-- MySQL (8.0+)
+-- Use a generated column + unique index
+
+-- SQLite
+CREATE UNIQUE INDEX user_employee_id_active ON User(employee_id) WHERE deleted_at IS NULL;
+```
+
+## Compound Primary Keys
+
+Full support for compound primary keys:
+
+```prisma
+model TenantUser {
+  tenantId   String
+  userId     String
+  email      String
+  deleted_at DateTime?
+
+  @@id([tenantId, userId])
+}
+```
+
+```typescript
+await safePrisma.tenantUser.softDelete({
+  where: {
+    tenantId_userId: { tenantId: 'tenant-1', userId: 'user-1' }
+  }
+});
+```
+
+## Soft Delete Detection
+
+Models are automatically detected as soft-deletable if they have a nullable DateTime field named:
+- `deleted_at` (snake_case)
+- `deletedAt` (camelCase)
+
+```prisma
+// Both of these work:
+model User {
+  deleted_at DateTime?  // snake_case
+}
+
+model Post {
+  deletedAt DateTime?   // camelCase
+}
+```
+
+## Known Limitations
+
+### Fluent API
+
+The Prisma fluent API bypasses the wrapper. Use `include` instead:
+
+```typescript
+// ❌ Does NOT filter deleted posts
+const posts = await safePrisma.user.findUnique({ where: { id: '1' } }).posts();
+
+// ✅ Correctly filters deleted posts
+const user = await safePrisma.user.findUnique({
+  where: { id: '1' },
+  include: { posts: true }
+});
+const posts = user.posts;
+```
+
+### Raw Queries
+
+Raw queries bypass the wrapper entirely (by design):
+
+```typescript
+// No filtering applied - returns all records including deleted
+const users = await safePrisma.$queryRaw`SELECT * FROM User`;
+```
+
+### Update/Upsert on Soft-Deleted Records
+
+`update` and `upsert` can still modify soft-deleted records. This is intentional to allow restoration workflows:
+
+```typescript
+// This works even if the user is soft-deleted
+await safePrisma.user.update({
+  where: { id: 'deleted-user' },
+  data: { deleted_at: null }  // Restore the user
+});
+```
+
+## Requirements
+
+- Node.js >= 18
+- Prisma >= 7.0.0
+- TypeScript >= 5.0 (recommended)
+
+## Development
+
+```bash
+# Start Postgres
+docker compose up -d
+
+# Run tests
+pnpm test
+
+# Stop Postgres
+docker compose down
+```
+
+## License
+
+MIT

package/dist/bin.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for prisma-safe-delete generator
+ *
+ * This file is invoked by Prisma when running `prisma generate`.
+ * It simply re-exports the generator module.
+ */
+import './generator.js';
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAEH,OAAO,gBAAgB,CAAC"}

package/dist/bin.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for prisma-safe-delete generator
+ *
+ * This file is invoked by Prisma when running `prisma generate`.
+ * It simply re-exports the generator module.
+ */
+import './generator.js';
+//# sourceMappingURL=bin.js.map

package/dist/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAEH,OAAO,gBAAgB,CAAC"}

package/dist/cascade-graph.d.ts

@@ -0,0 +1,54 @@
+import type { ParsedModel, ParsedSchema } from './dmmf-parser.js';
+/**
+ * Represents a child model in a cascade relationship
+ */
+export interface CascadeChild {
+    /** The name of the child model */
+    model: string;
+    /** The foreign key field(s) on the child model */
+    foreignKey: string[];
+    /** The primary key field(s) on the parent model that the FK references */
+    parentKey: string[];
+    /** Whether the child model supports soft deletion */
+    isSoftDeletable: boolean;
+    /** The name of the deleted_at field if soft-deletable */
+    deletedAtField: string | null;
+}
+/**
+ * Maps parent model names to their cascade children
+ * When a parent is soft-deleted, all children in this map should be cascaded
+ */
+export type CascadeGraph = Record<string, CascadeChild[]>;
+/**
+ * Builds a cascade graph from a parsed schema
+ *
+ * The graph maps parent model names to lists of child models that should be
+ * soft-deleted when the parent is soft-deleted. Only relations with
+ * onDelete: Cascade are included.
+ *
+ * @param schema - The parsed Prisma schema
+ * @returns A cascade graph mapping parents to children
+ */
+export declare function buildCascadeGraph(schema: ParsedSchema): CascadeGraph;
+/**
+ * Gets all models that would be affected by cascading from a given model
+ * Returns models in depth-first order (leaf nodes first)
+ *
+ * @param graph - The cascade graph
+ * @param modelName - The starting model name
+ * @returns Array of model names in cascade order
+ */
+export declare function getCascadeOrder(graph: CascadeGraph, modelName: string): string[];
+/**
+ * Gets the direct children of a model in the cascade graph
+ */
+export declare function getDirectChildren(graph: CascadeGraph, modelName: string): CascadeChild[];
+/**
+ * Checks if a model has any cascade children
+ */
+export declare function hasCascadeChildren(graph: CascadeGraph, modelName: string): boolean;
+/**
+ * Gets all soft-deletable children (direct and indirect) of a model
+ */
+export declare function getSoftDeletableDescendants(graph: CascadeGraph, schema: ParsedSchema, modelName: string): ParsedModel[];
+//# sourceMappingURL=cascade-graph.d.ts.map

package/dist/cascade-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cascade-graph.d.ts","sourceRoot":"","sources":["../src/cascade-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,0EAA0E;IAC1E,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,qDAAqD;IACrD,eAAe,EAAE,OAAO,CAAC;IACzB,yDAAyD;IACzD,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;AAE1D;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAyDpE;AASD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,GAChB,MAAM,EAAE,CAsBV;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,GAChB,YAAY,EAAE,CAEhB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAGT;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,GAChB,WAAW,EAAE,CAiBf"}

package/dist/cascade-graph.js

@@ -0,0 +1,123 @@
+/**
+ * Builds a cascade graph from a parsed schema
+ *
+ * The graph maps parent model names to lists of child models that should be
+ * soft-deleted when the parent is soft-deleted. Only relations with
+ * onDelete: Cascade are included.
+ *
+ * @param schema - The parsed Prisma schema
+ * @returns A cascade graph mapping parents to children
+ */
+export function buildCascadeGraph(schema) {
+    const graph = {};
+    // Initialize empty arrays for all models
+    for (const model of schema.models) {
+        graph[model.name] = [];
+    }
+    // For each model, look at its relations to find cascade relationships
+    for (const model of schema.models) {
+        for (const relation of model.relations) {
+            // We only care about relations that have onDelete: Cascade
+            if (relation.onDelete !== 'Cascade') {
+                continue;
+            }
+            // Skip list relations - they're the "one" side, we want the "many" side
+            // The relation with the foreign key is the child
+            if (relation.isList) {
+                continue;
+            }
+            // This model (with the FK) is the child, relation.type is the parent
+            const parentModelName = relation.type;
+            const parentModel = schema.modelMap.get(parentModelName);
+            if (parentModel === undefined) {
+                continue;
+            }
+            // Get the parent's primary key (what the FK references)
+            const parentKey = normalizeKey(parentModel.primaryKey);
+            const foreignKey = relation.foreignKey;
+            // Skip if we don't have FK information
+            if (foreignKey.length === 0) {
+                continue;
+            }
+            // Get or create the children array for this parent
+            let children = graph[parentModelName];
+            if (children === undefined) {
+                children = [];
+                graph[parentModelName] = children;
+            }
+            children.push({
+                model: model.name,
+                foreignKey,
+                parentKey,
+                isSoftDeletable: model.isSoftDeletable,
+                deletedAtField: model.deletedAtField,
+            });
+        }
+    }
+    return graph;
+}
+/**
+ * Normalizes a primary key to always be an array
+ */
+function normalizeKey(key) {
+    return Array.isArray(key) ? key : [key];
+}
+/**
+ * Gets all models that would be affected by cascading from a given model
+ * Returns models in depth-first order (leaf nodes first)
+ *
+ * @param graph - The cascade graph
+ * @param modelName - The starting model name
+ * @returns Array of model names in cascade order
+ */
+export function getCascadeOrder(graph, modelName) {
+    const visited = new Set();
+    const result = [];
+    function visit(name) {
+        if (visited.has(name)) {
+            return;
+        }
+        visited.add(name);
+        const children = graph[name];
+        if (children !== undefined) {
+            for (const child of children) {
+                visit(child.model);
+            }
+        }
+        result.push(name);
+    }
+    visit(modelName);
+    return result;
+}
+/**
+ * Gets the direct children of a model in the cascade graph
+ */
+export function getDirectChildren(graph, modelName) {
+    return graph[modelName] ?? [];
+}
+/**
+ * Checks if a model has any cascade children
+ */
+export function hasCascadeChildren(graph, modelName) {
+    const children = graph[modelName];
+    return children !== undefined && children.length > 0;
+}
+/**
+ * Gets all soft-deletable children (direct and indirect) of a model
+ */
+export function getSoftDeletableDescendants(graph, schema, modelName) {
+    const order = getCascadeOrder(graph, modelName);
+    const descendants = [];
+    for (const name of order) {
+        // Skip the starting model itself
+        if (name === modelName) {
+            continue;
+        }
+        const model = schema.modelMap.get(name);
+        if (model?.isSoftDeletable === true) {
+            descendants.push(model);
+        }
+    }
+    return descendants;
+}
+//# sourceMappingURL=cascade-graph.js.map