@holoyan/adonisjs-polymorphic 0.1.0

package/README.md

@@ -0,0 +1,549 @@
+# @holoyan/adonisjs-polymorphic
+
+Polymorphic relations for [AdonisJS Lucid ORM](https://lucid.adonisjs.com) — `morphOne`, `morphMany`, and `morphTo`.
+
+| Package version | AdonisJS version |
+|---|---|
+| v0.x | v6 + v7 |
+
+---
+
+## How can you support me?
+
+It's simple — just star this repository. That is enough to keep me motivated to maintain this package.
+
+---
+
+## Related packages
+
+- [@holoyan/adonisjs-permissions](https://github.com/holoyan/adonisjs-permissions) — Role & permission system for AdonisJS. Supports multi-model ACL, resource-level permissions, scopes (multi-tenancy), and events.
+- [@holoyan/morph-map-js](https://github.com/holoyan/morph-map-js) — The framework-agnostic morph map registry that powers the `@MorphMap` decorator used by this package.
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [What are polymorphic relations?](#what-are-polymorphic-relations)
+- [morphOne](#morphone)
+- [morphMany](#morphmany)
+- [morphTo](#morphto)
+- [Global morph map with @MorphMap](#global-morph-map-with-morphmap)
+- [Options reference](#options-reference)
+
+---
+
+## Installation
+
+```bash
+npm install @holoyan/adonisjs-polymorphic
+```
+
+Register the service provider by running the configure command:
+
+```bash
+node ace configure @holoyan/adonisjs-polymorphic
+```
+
+This automatically adds the provider to your `adonisrc.ts`.
+
+---
+
+## What are polymorphic relations?
+
+A polymorphic relation lets a single child model belong to more than one parent model using a shared pair of columns — a **type** column and an **id** column.
+
+```
+images
+  id
+  url
+  imageable_type   ← 'posts' | 'videos'
+  imageable_id     ← id of the parent row
+```
+
+This means a single `images` table can store thumbnails for both posts and videos without needing separate `post_images` and `video_images` tables.
+
+---
+
+## morphOne
+
+A parent model **has one** polymorphic child.
+
+### Database migration
+
+```ts
+await schema.createTable('images', (table) => {
+  table.increments('id')
+  table.string('url').notNullable()
+  table.string('imageable_type').notNullable()
+  table.integer('imageable_id').notNullable()
+  table.index(['imageable_type', 'imageable_id'])
+})
+```
+
+### Model setup
+
+```ts
+// app/models/image.ts
+import { BaseModel, column } from '@adonisjs/lucid/orm'
+import { morphTo } from '@holoyan/adonisjs-polymorphic'
+import Post from '#models/post'
+import Video from '#models/video'
+
+export default class Image extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare url: string
+
+  @column()
+  declare imageableType: string
+
+  @column()
+  declare imageableId: number
+
+  @morphTo({ name: 'imageable', morphMap: { posts: () => Post, videos: () => Video } })
+  declare imageable: Post | Video | null
+}
+```
+
+```ts
+// app/models/post.ts
+import { BaseModel, column } from '@adonisjs/lucid/orm'
+import { morphOne } from '@holoyan/adonisjs-polymorphic'
+import Image from '#models/image'
+
+export default class Post extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare title: string
+
+  @morphOne(() => Image, { name: 'imageable' })
+  declare image: Image | null
+}
+```
+
+```ts
+// app/models/video.ts
+import { BaseModel, column } from '@adonisjs/lucid/orm'
+import { morphOne } from '@holoyan/adonisjs-polymorphic'
+import Image from '#models/image'
+
+export default class Video extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare title: string
+
+  @morphOne(() => Image, { name: 'imageable' })
+  declare image: Image | null
+}
+```
+
+### Querying
+
+**Eager load (preload):**
+
+```ts
+const post = await (Post.query() as any)
+  .preload('image')
+  .firstOrFail()
+
+console.log(post.image)         // Image | null
+console.log(post.image?.url)    // 'photo.jpg'
+```
+
+**Preload multiple parents at once:**
+
+```ts
+const posts = await (Post.query() as any)
+  .preload('image') as Post[]
+
+// One SQL query — no N+1
+// SELECT * FROM images WHERE imageable_type = 'posts' AND imageable_id IN (1, 2, 3)
+```
+
+**Ad-hoc query:**
+
+```ts
+const image = await (post as any)
+  .related('image')
+  .query()
+  .firstOrFail()
+```
+
+### Writing
+
+**Create a related image:**
+
+```ts
+// imageableType and imageableId are set automatically
+const image = await (post as any)
+  .related('image')
+  .create({ url: 'photo.jpg' })
+```
+
+**Save an existing image instance:**
+
+```ts
+const image = new Image()
+image.url = 'photo.jpg'
+
+await (post as any).related('image').save(image)
+```
+
+**Find or create:**
+
+```ts
+const image = await (post as any)
+  .related('image')
+  .firstOrCreate({ url: 'photo.jpg' })
+```
+
+**Update or create:**
+
+```ts
+const image = await (post as any)
+  .related('image')
+  .updateOrCreate({ imageableId: post.id }, { url: 'new-photo.jpg' })
+```
+
+---
+
+## morphMany
+
+A parent model **has many** polymorphic children. Works exactly like `morphOne` but returns an array.
+
+### Database migration
+
+```ts
+await schema.createTable('comments', (table) => {
+  table.increments('id')
+  table.text('body').notNullable()
+  table.string('commentable_type').nullable()
+  table.integer('commentable_id').nullable()
+  table.index(['commentable_type', 'commentable_id'])
+})
+```
+
+### Model setup
+
+```ts
+// app/models/comment.ts
+import { BaseModel, column } from '@adonisjs/lucid/orm'
+import { morphTo } from '@holoyan/adonisjs-polymorphic'
+import Post from '#models/post'
+import Video from '#models/video'
+
+export default class Comment extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare body: string
+
+  @column()
+  declare commentableType: string
+
+  @column()
+  declare commentableId: number
+
+  @morphTo({ name: 'commentable', morphMap: { posts: () => Post, videos: () => Video } })
+  declare commentable: Post | Video | null
+}
+```
+
+```ts
+// app/models/post.ts
+import { morphOne, morphMany } from '@holoyan/adonisjs-polymorphic'
+import Image from '#models/image'
+import Comment from '#models/comment'
+
+export default class Post extends BaseModel {
+  // ...
+
+  @morphOne(() => Image, { name: 'imageable' })
+  declare image: Image | null
+
+  @morphMany(() => Comment, { name: 'commentable' })
+  declare comments: Comment[]
+}
+```
+
+### Querying
+
+**Eager load:**
+
+```ts
+const post = await (Post.query() as any)
+  .preload('comments')
+  .firstOrFail()
+
+console.log(post.comments)          // Comment[]
+console.log(post.comments.length)   // 3
+```
+
+**Comments are isolated by type — a post only gets its own comments, not a video's:**
+
+```ts
+const post = await (Post.query() as any).preload('comments').firstOrFail()
+const video = await (Video.query() as any).preload('comments').firstOrFail()
+
+// Each only sees their own comments
+```
+
+**Ad-hoc query with additional constraints:**
+
+```ts
+const recentComments = await (post as any)
+  .related('comments')
+  .query()
+  .orderBy('created_at', 'desc')
+  .limit(5)
+```
+
+### Writing
+
+**Create one:**
+
+```ts
+const comment = await (post as any)
+  .related('comments')
+  .create({ body: 'Great post!' })
+
+console.log(comment.commentableType)  // 'posts'
+console.log(comment.commentableId)    // post.id
+```
+
+**Create many:**
+
+```ts
+await (post as any).related('comments').createMany([
+  { body: 'First comment' },
+  { body: 'Second comment' },
+])
+```
+
+**Save an existing instance:**
+
+```ts
+const comment = new Comment()
+comment.body = 'Hello'
+
+await (post as any).related('comments').save(comment)
+```
+
+**Save many:**
+
+```ts
+await (post as any).related('comments').saveMany([comment1, comment2])
+```
+
+---
+
+## morphTo
+
+The child side of a polymorphic relation. A comment **belongs to** either a `Post` or a `Video`.
+
+### Querying
+
+**Preload the parent:**
+
+```ts
+const comment = await (Comment.query() as any)
+  .preload('commentable')
+  .firstOrFail()
+
+if (comment.commentable instanceof Post) {
+  console.log('belongs to a post:', comment.commentable.title)
+} else if (comment.commentable instanceof Video) {
+  console.log('belongs to a video:', comment.commentable.title)
+}
+```
+
+**Preload mixed parent types in one query:**
+
+```ts
+// All comments in one query, parents resolved in two queries (posts + videos)
+const comments = await (Comment.query() as any)
+  .preload('commentable') as Comment[]
+```
+
+**Ad-hoc query:**
+
+```ts
+const parent = await (comment as any)
+  .related('commentable')
+  .query()
+  .firstOrFail()
+```
+
+### Writing
+
+**Associate with a parent:**
+
+```ts
+const post = await Post.findOrFail(1)
+await (comment as any).related('commentable').associate(post)
+
+// comment.commentableType is now 'posts'
+// comment.commentableId is now post.id
+```
+
+**Dissociate from parent:**
+
+```ts
+await (comment as any).related('commentable').dissociate()
+
+// comment.commentableType is now null
+// comment.commentableId is now null
+```
+
+---
+
+## Global morph map with @MorphMap
+
+When you have many `morphTo` relations, repeating `morphMap: { posts: () => Post, videos: () => Video }` on each one gets tedious. Use the `@MorphMap` decorator from `@holoyan/morph-map-js` (bundled as a dependency) to register each model once globally.
+
+### Setup
+
+Decorate each parent model with its alias:
+
+```ts
+// app/models/post.ts
+import { MorphMap } from '@holoyan/morph-map-js'
+
+@MorphMap('posts')
+export default class Post extends BaseModel {
+  // ...
+}
+```
+
+```ts
+// app/models/video.ts
+import { MorphMap } from '@holoyan/morph-map-js'
+
+@MorphMap('videos')
+export default class Video extends BaseModel {
+  // ...
+}
+```
+
+Now `morphTo` relations can omit the `morphMap` option entirely:
+
+```ts
+// app/models/comment.ts
+import { morphTo } from '@holoyan/adonisjs-polymorphic'
+
+export default class Comment extends BaseModel {
+  @column()
+  declare commentableType: string
+
+  @column()
+  declare commentableId: number
+
+  // No morphMap needed — resolved from global registry at query time
+  @morphTo({ name: 'commentable' })
+  declare commentable: Post | Video | null
+}
+```
+
+Adding a new parent type (e.g. `Podcast`) only requires one change:
+
+```ts
+@MorphMap('podcasts')
+export default class Podcast extends BaseModel {}
+```
+
+All existing `morphTo` relations pick it up automatically.
+
+### Alias vs table name
+
+The `@MorphMap` alias is also used as the `morphValue` stored in the type column. This lets you decouple the alias from the table name:
+
+```ts
+@MorphMap('post')        // alias stored in type column
+export default class Post extends BaseModel {
+  static table = 'posts' // actual DB table
+}
+```
+
+```ts
+@morphOne(() => Image, { name: 'imageable' })
+// morphValue will be 'post' (from @MorphMap), not 'posts' (from table)
+```
+
+### Ensuring models are registered at boot time
+
+The global registry is populated when a model file is **imported**. To guarantee the registry is fully populated before any request, seeder, or test query runs, register your parent models in `config/polymorphic.ts` (published automatically by `node ace configure`):
+
+```ts
+// config/polymorphic.ts
+import { defineConfig } from '@holoyan/adonisjs-polymorphic'
+
+export default defineConfig({
+  morphModels: [
+    () => import('#models/post'),
+    () => import('#models/video'),
+    () => import('#models/podcast'),  // add new parent models here
+  ],
+})
+```
+
+The service provider imports all listed models during `boot()` — before the app serves any request, before seeders run, before tests execute. This completely eliminates any load order concerns.
+
+Every time you add a new model decorated with `@MorphMap`, add it to this list.
+
+### Explicit morphMap always wins
+
+You can always override the registry on a per-relation basis:
+
+```ts
+@morphTo({
+  name: 'commentable',
+  morphMap: { posts: () => Post },  // only posts, ignores registry
+})
+declare commentable: Post | null
+```
+
+### Priority order
+
+| What's set | morphTo resolution | morphOne/morphMany morphValue |
+|---|---|---|
+| Explicit `morphMap` option | Used directly | — |
+| `morphValue` option | — | Used directly |
+| `@MorphMap` on model | Registry fallback | Registry alias |
+| Nothing | Error at query time | `model.table` |
+
+---
+
+## Options reference
+
+### `@morphOne(relatedModel, options)`
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `name` | `string` | **required** | Prefix for the type/id columns on the related model. `'imageable'` → `imageableType` + `imageableId` |
+| `localKey` | `string` | primary key | Attribute on the parent used to match against the id column |
+| `morphValue` | `string` | `@MorphMap` alias or `model.table` | Value stored in the type column to identify this parent |
+| `serializeAs` | `string \| null` | relation name | Key used during serialization. `null` excludes it |
+| `onQuery` | `(query) => void` | — | Hook to add default constraints to every query on this relation |
+
+### `@morphMany(relatedModel, options)`
+
+Same options as `@morphOne`.
+
+### `@morphTo(options)`
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `name` | `string` | relation name | Prefix used to derive the type/id attribute names on this model |
+| `morphMap` | `Record<string, () => Model>` | global registry | Maps type strings to model factories. Optional when `@MorphMap` is used |
+| `typeKey` | `string` | `${name}Type` | Explicit attribute name for the type column if it doesn't follow the naming convention |
+| `idKey` | `string` | `${name}Id` | Explicit attribute name for the id column if it doesn't follow the naming convention |
+| `serializeAs` | `string \| null` | relation name | Key used during serialization. `null` excludes it |
+| `onQuery` | `(query) => void` | — | Hook to add default constraints |

package/build/configure.d.ts

@@ -0,0 +1,10 @@
+import type Configure from '@adonisjs/core/commands/configure';
+/**
+ * Configure hook — runs when the user executes:
+ *   node ace configure @holoyan/adonisjs-polymorphic
+ *
+ * - Registers the service provider in adonisrc.ts
+ * - Publishes config/polymorphic.ts
+ */
+export declare function configure(command: Configure): Promise<void>;
+//# sourceMappingURL=configure.d.ts.map

package/build/configure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../configure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,mCAAmC,CAAA;AAG9D;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,SAAS,iBAoBjD"}

package/build/configure.js

@@ -0,0 +1,27 @@
+import { stubsRoot } from './stubs/main.js';
+/**
+ * Configure hook — runs when the user executes:
+ *   node ace configure @holoyan/adonisjs-polymorphic
+ *
+ * - Registers the service provider in adonisrc.ts
+ * - Publishes config/polymorphic.ts
+ */
+export async function configure(command) {
+    const codemods = await command.createCodemods();
+    await codemods.updateRcFile((rcFile) => {
+        rcFile.addProvider('@holoyan/adonisjs-polymorphic/provider');
+    });
+    await codemods.makeUsingStub(stubsRoot, 'config/polymorphic.stub', {});
+    command.logger.log('');
+    command.logger.log('  Install complete. Next steps:');
+    command.logger.log('');
+    command.logger.log('  1. Decorate your parent models with @MorphMap:');
+    command.logger.log('       @MorphMap(\'posts\') export default class Post extends BaseModel {}');
+    command.logger.log('');
+    command.logger.log('  2. Register them in config/polymorphic.ts:');
+    command.logger.log('       morphModels: [() => import(\'#models/post\')]');
+    command.logger.log('');
+    command.logger.log('  3. Use @morphOne, @morphMany, @morphTo in your models.');
+    command.logger.log('');
+}
+//# sourceMappingURL=configure.js.map

package/build/configure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.js","sourceRoot":"","sources":["../configure.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,OAAkB;IAChD,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,cAAc,EAAE,CAAA;IAE/C,MAAM,QAAQ,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,EAAE;QACrC,MAAM,CAAC,WAAW,CAAC,wCAAwC,CAAC,CAAA;IAC9D,CAAC,CAAC,CAAA;IAEF,MAAM,QAAQ,CAAC,aAAa,CAAC,SAAS,EAAE,yBAAyB,EAAE,EAAE,CAAC,CAAA;IAEtE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACtB,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,iCAAiC,CAAC,CAAA;IACrD,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACtB,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,kDAAkD,CAAC,CAAA;IACtE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,4EAA4E,CAAC,CAAA;IAChG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACtB,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,8CAA8C,CAAC,CAAA;IAClE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,sDAAsD,CAAC,CAAA;IAC1E,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACtB,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,0DAA0D,CAAC,CAAA;IAC9E,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;AACxB,CAAC"}

package/build/providers/plugin_provider.d.ts

@@ -0,0 +1,15 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+/**
+ * Service provider for @holoyan/adonisjs-polymorphic.
+ *
+ * During boot, imports every model listed in config/polymorphic.ts so that
+ * @MorphMap decorators run and the global registry is fully populated before
+ * any request, command, or test query executes.
+ */
+export default class PolymorphicProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    register(): void;
+    boot(): Promise<void>;
+}
+//# sourceMappingURL=plugin_provider.d.ts.map

package/build/providers/plugin_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin_provider.d.ts","sourceRoot":"","sources":["../../providers/plugin_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAG9D;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAmB;IAC1B,SAAS,CAAC,GAAG,EAAE,kBAAkB;gBAAvB,GAAG,EAAE,kBAAkB;IAE7C,QAAQ;IAEF,IAAI;CAOX"}

package/build/providers/plugin_provider.js

@@ -0,0 +1,21 @@
+/**
+ * Service provider for @holoyan/adonisjs-polymorphic.
+ *
+ * During boot, imports every model listed in config/polymorphic.ts so that
+ * @MorphMap decorators run and the global registry is fully populated before
+ * any request, command, or test query executes.
+ */
+export default class PolymorphicProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    register() { }
+    async boot() {
+        const config = this.app.config.get('polymorphic', {});
+        if (config.morphModels?.length) {
+            await Promise.all(config.morphModels.map((factory) => factory()));
+        }
+    }
+}
+//# sourceMappingURL=plugin_provider.js.map

package/build/providers/plugin_provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin_provider.js","sourceRoot":"","sources":["../../providers/plugin_provider.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAmB;IAChB;IAAtB,YAAsB,GAAuB;QAAvB,QAAG,GAAH,GAAG,CAAoB;IAAG,CAAC;IAEjD,QAAQ,KAAI,CAAC;IAEb,KAAK,CAAC,IAAI;QACR,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAoB,aAAa,EAAE,EAAE,CAAC,CAAA;QAExE,IAAI,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;YAC/B,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;QACnE,CAAC;IACH,CAAC;CACF"}

package/build/src/decorators.d.ts

@@ -0,0 +1,41 @@
+import type { MorphOneOptions, MorphManyOptions, MorphToOptions } from './types.js';
+/**
+ * Decorator to define a morphOne (has-one polymorphic) relation on a parent model.
+ *
+ * @example
+ * ```ts
+ * class Post extends BaseModel {
+ *   @morphOne(() => Image, { name: 'imageable' })
+ *   declare image: Image | null
+ * }
+ * ```
+ */
+export declare function morphOne(relatedModelFactory: () => any, options: MorphOneOptions): (target: any, relationName: string) => void;
+/**
+ * Decorator to define a morphMany (has-many polymorphic) relation on a parent model.
+ *
+ * @example
+ * ```ts
+ * class Post extends BaseModel {
+ *   @morphMany(() => Comment, { name: 'commentable' })
+ *   declare comments: Comment[]
+ * }
+ * ```
+ */
+export declare function morphMany(relatedModelFactory: () => any, options: MorphManyOptions): (target: any, relationName: string) => void;
+/**
+ * Decorator to define a morphTo (belongs-to polymorphic) relation on a child model.
+ *
+ * @example
+ * ```ts
+ * class Comment extends BaseModel {
+ *   @column() declare commentableType: string
+ *   @column() declare commentableId: number
+ *
+ *   @morphTo({ name: 'commentable', morphMap: { posts: () => Post, videos: () => Video } })
+ *   declare commentable: Post | Video | null
+ * }
+ * ```
+ */
+export declare function morphTo(options: MorphToOptions): (target: any, relationName: string) => void;
+//# sourceMappingURL=decorators.d.ts.map

package/build/src/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEnF;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,mBAAmB,EAAE,MAAM,GAAG,EAAE,OAAO,EAAE,eAAe,IAC5C,QAAQ,GAAG,EAAE,cAAc,MAAM,UAMrE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,mBAAmB,EAAE,MAAM,GAAG,EAAE,OAAO,EAAE,gBAAgB,IAC7C,QAAQ,GAAG,EAAE,cAAc,MAAM,UAMtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc,IACX,QAAQ,GAAG,EAAE,cAAc,MAAM,UAMpE"}