@adminide-stack/marketplace-module-server 12.0.4-alpha.92 → 13.0.1-alpha.0

package/Readme.md

@@ -0,0 +1,321 @@
+# Extension Marketplace Server
+
+This module handles the extension marketplace functionality, including extension registry management, installation lifecycle, and publisher actions.
+
+## Extension Lifecycle Management
+
+### Overview
+
+Publishers should generally **not** be able to completely unregister extensions that users have already installed, but there are nuanced approaches to handle extension lifecycle scenarios while balancing publisher needs, user expectations, and platform security.
+
+## Recommended Approach: Soft Deprecation vs Hard Removal
+
+### 1. Publisher Actions Available
+
+```json
+// In extensionRegistry collection
+{
+  "_id": ObjectId("67c2c30f860196612c58b082"),
+  "extensionID": "stackflow1/builder-extension",
+  "publisher": "stackflow1",
+  "status": "active", // active, deprecated, suspended, removed
+  "deprecation": {
+    "isDeprecated": false,
+    "deprecatedAt": null,
+    "reason": null, // "security", "maintenance", "replaced", "violation"
+    "replacementExtension": null, // Alternative extension ID
+    "endOfLifeDate": null, // When it will stop working
+    "migrationGuide": null // URL to migration instructions
+  },
+  "publisherActions": {
+    "canDeprecate": true,
+    "canSuspendNewInstalls": true,
+    "canRemoveFromMarketplace": true,
+    "canForceUninstall": false // Requires admin approval
+  },
+  "versions": [
+    {
+      "version": "1.0.0",
+      "status": "active", // active, deprecated, yanked, security-hold
+      "yankedAt": null,
+      "yankedReason": null
+    }
+  ]
+}
+```
+
+### 2. Enhanced installedExtensions with Lifecycle Management
+
+```json
+// In installedExtensions collection
+{
+  "_id": ObjectId("67c2c30f860196612c58b080"),
+  "tenantId": "default",
+  "registryRef": ObjectId("67c2c30f860196612c58b082"),
+  "extensionID": "stackflow1/builder-extension",
+  "installedVersion": "1.0.0",
+  "status": "installed", // installed, deprecated-installed, suspended, orphaned
+  "lifecycle": {
+    "registryStatus": "active", // Cached from registry
+    "isOrphaned": false, // True if extension removed from registry
+    "deprecationWarningShown": false,
+    "autoUpdateBlocked": false,
+    "lastRegistryCheck": ISODate("2025-03-01T11:00:00.000+0000")
+  },
+  "policies": {
+    "allowOrphanedExecution": true, // Admin policy
+    "requireSecurityUpdates": true,
+    "autoRemoveDeprecated": false,
+    "deprecationGracePeriod": 90 // days
+  }
+}
+```
+
+## Publisher Actions and Their Effects
+
+### 1. **Deprecate Extension** (Recommended)
+
+```javascript
+// Publisher action: Deprecate
+db.extensionRegistry.updateOne(
+    { extensionID: 'stackflow1/builder-extension' },
+    {
+        $set: {
+            status: 'deprecated',
+            deprecation: {
+                isDeprecated: true,
+                deprecatedAt: new Date(),
+                reason: 'maintenance',
+                replacementExtension: 'stackflow1/builder-v2',
+                endOfLifeDate: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000), // 1 year
+                migrationGuide: 'https://docs.example.com/migration-guide',
+            },
+        },
+    },
+);
+
+// Effect on installed extensions: Still works, but users get warnings
+db.installedExtensions.updateMany(
+    { extensionID: 'stackflow1/builder-extension' },
+    {
+        $set: {
+            status: 'deprecated-installed',
+            'lifecycle.registryStatus': 'deprecated',
+        },
+    },
+);
+```
+
+### 2. **Suspend New Installations**
+
+```javascript
+// Publisher action: Suspend new installs (existing continue to work)
+db.extensionRegistry.updateOne(
+    { extensionID: 'stackflow1/builder-extension' },
+    {
+        $set: {
+            status: 'suspended',
+            suspension: {
+                suspendedAt: new Date(),
+                reason: 'security-review',
+                allowExistingInstalls: true,
+                estimatedResolution: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+            },
+        },
+    },
+);
+```
+
+### 3. **Remove from Marketplace** (Registry remains for installed extensions)
+
+```javascript
+// Publisher action: Remove from marketplace but keep registry entry
+db.extensionRegistry.updateOne(
+    { extensionID: 'stackflow1/builder-extension' },
+    {
+        $set: {
+            status: 'removed',
+            marketplaceVisibility: 'hidden',
+            removal: {
+                removedAt: new Date(),
+                reason: 'discontinued',
+                keepForInstalledUsers: true,
+            },
+        },
+    },
+);
+
+// Installed extensions become "orphaned" but continue to work
+db.installedExtensions.updateMany(
+    { extensionID: 'stackflow1/builder-extension' },
+    {
+        $set: {
+            status: 'orphaned',
+            'lifecycle.isOrphaned': true,
+            'lifecycle.registryStatus': 'removed',
+        },
+    },
+);
+```
+
+### 4. **Emergency Removal** (Admin-only, rare cases)
+
+```javascript
+// Admin/Platform action only (security issues, legal violations)
+db.extensionRegistry.updateOne(
+    { extensionID: 'stackflow1/builder-extension' },
+    {
+        $set: {
+            status: 'emergency-removed',
+            emergencyRemoval: {
+                removedAt: new Date(),
+                removedBy: 'platform-admin',
+                reason: 'security-vulnerability',
+                forceUninstall: true,
+                notificationSent: true,
+            },
+        },
+    },
+);
+
+// Force disable all installations
+db.installedExtensions.updateMany(
+    { extensionID: 'stackflow1/builder-extension' },
+    {
+        $set: {
+            status: 'force-disabled',
+            'settings.systemEnabled': false,
+            'settings.effectiveEnabled': false,
+            'runtime.activationState': 'disabled-by-admin',
+        },
+    },
+);
+```
+
+## User Experience for Different Scenarios
+
+### 1. Deprecated Extension
+
+```typescript
+// User sees warning but extension continues to work
+interface DeprecationWarning {
+    type: 'deprecation';
+    message: 'Builder Extension is deprecated and will stop working on March 1, 2026';
+    actions: [
+        { label: 'View Migration Guide'; url: 'https://docs.example.com/migration' },
+        { label: 'Install Replacement'; extensionID: 'stackflow1/builder-v2' },
+        { label: 'Dismiss'; action: 'dismiss' },
+    ];
+}
+```
+
+### 2. Suspended Extension
+
+```typescript
+// User sees info but extension continues to work
+interface SuspensionNotice {
+    type: 'suspension';
+    message: 'Builder Extension is under security review. Updates suspended temporarily.';
+    estimatedResolution: '2025-03-08T00:00:00Z';
+}
+```
+
+### 3. Orphaned Extension (Removed from marketplace)
+
+```typescript
+// User sees warning about no more updates
+interface OrphanedWarning {
+    type: 'orphaned';
+    message: 'Builder Extension is no longer maintained. No updates will be available.';
+    actions: [
+        { label: 'Find Alternatives'; action: 'browse-alternatives' },
+        { label: 'Keep Using'; action: 'accept-risk' },
+        { label: 'Uninstall'; action: 'uninstall' },
+    ];
+}
+```
+
+## Administrative Policies
+
+```json
+// In tenant/organization settings
+{
+    "extensionPolicies": {
+        "orphanedExtensions": {
+            "allowExecution": true,
+            "showWarnings": true,
+            "autoRemoveAfterDays": null
+        },
+        "deprecatedExtensions": {
+            "allowNewActivations": true,
+            "gracePeriodDays": 90,
+            "forceRemovalAfterEOL": false
+        },
+        "suspendedExtensions": {
+            "allowContinuedUse": true,
+            "disableAfterDays": null
+        },
+        "securityPolicies": {
+            "respectEmergencyDisables": true,
+            "allowManualOverride": false
+        }
+    }
+}
+```
+
+## Query Examples
+
+### Get Extensions Needing User Attention
+
+```javascript
+db.installedExtensions.aggregate([
+    {
+        $match: {
+            tenantId: 'default',
+            'lifecycle.registryStatus': { $in: ['deprecated', 'suspended', 'removed'] },
+        },
+    },
+    {
+        $lookup: {
+            from: 'extensionRegistry',
+            localField: 'registryRef',
+            foreignField: '_id',
+            as: 'registry',
+        },
+    },
+    {
+        $project: {
+            extensionID: 1,
+            status: 1,
+            lifecycle: 1,
+            deprecation: '$registry.deprecation',
+            suspension: '$registry.suspension',
+        },
+    },
+]);
+```
+
+## Best Practices
+
+### Publishers Should:
+
+-   Use deprecation for planned discontinuation
+-   Provide migration guides and alternatives
+-   Give reasonable notice periods (6-12 months)
+-   Only request emergency removal for serious issues
+
+### Platform Should:
+
+-   Require admin approval for emergency removals
+-   Maintain registry entries for installed extensions
+-   Provide clear user notifications
+-   Allow organizational policies to override defaults
+
+### Users Should:
+
+-   Receive clear warnings about extension status changes
+-   Have time to migrate to alternatives
+-   Retain control over their installed extensions
+-   Be able to accept risks of using orphaned extensions
+
+This approach balances publisher needs, user expectations, and platform security while avoiding the disruption of completely removing extensions that users depend on.

package/lib/containers/module.d.ts

@@ -1,3 +1,11 @@
 import { interfaces } from 'inversify';
+import { IInstalledExtensionService, IMarketplacePublisherService, IPublisherEventService, IExtensionGalleryService } from 'common/server';
 export declare const extensionModule: (settings: any) => interfaces.ContainerModule;
+declare const createServiceFunc: (container: interfaces.Container) => {
+    installedExtensionService: IInstalledExtensionService;
+    publisherService: IMarketplacePublisherService;
+    publisherEventService: IPublisherEventService;
+    extensionGalleryService: IExtensionGalleryService;
+};
+export { createServiceFunc };
 //# sourceMappingURL=module.d.ts.map

package/lib/containers/module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/containers/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,UAAU,EAAE,MAAM,WAAW,CAAC;AAKxD,eAAO,MAAM,eAAe,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,UAAU,CAAC,eActD,CAAC"}
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/containers/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,UAAU,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAEH,0BAA0B,EAG1B,4BAA4B,EAC5B,sBAAsB,EACtB,wBAAwB,EAE3B,MAAM,eAAe,CAAC;AAWvB,eAAO,MAAM,eAAe,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,UAAU,CAAC,eAgDtD,CAAC;AAGP,QAAA,MAAM,iBAAiB,GAAI,WAAW,UAAU,CAAC,SAAS;;;;;CAKxD,CAAC;AAEH,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/lib/containers/module.js

@@ -1,7 +1,18 @@
-import {ContainerModule}from'inversify';import {SERVER_TYPES}from'common/server';import {RegistryExtensionService}from'../services/extension-service.js';import'../store/models/registry-extension-model.js';import {RegistryExtensionRepository}from'../store/repository/registry-extension-repository.js';const extensionModule = settings => new ContainerModule(bind => {
+import {ContainerModule}from'inversify';import {SERVER_TYPES}from'common/server';import'../services/installed-extension-service.js';import {InstalledExtensionServiceExt}from'../services/installed-extension-service-ext.js';import {MarketplacePublisherService}from'../services/publisher-service.js';import {PublisherEventService}from'../services/publisher-event-service.js';import {ExtensionGalleryService}from'../services/extension-gallery-service.js';import {ExtensionGalleryRepository}from'../services/extension-gallery-repository.js';import'../store/models/installed-extension-model.js';import'../store/models/publisher-model.js';import {InstalledExtensionRepository}from'../store/repositories/installed-extension-repository.js';import {MarketplacePublisherRepository}from'../store/repositories/publisher-repository.js';import {DropOldPublisherNameIndexMigration}from'../migrations/dbMigrations/DropOldPublisherIndexMigration.js';const extensionModule = settings => new ContainerModule(bind => {
   bind(SERVER_TYPES.IExtensionMongoConnection).toConstantValue(settings.mongoConnection);
-  // Extension Service
-  bind(SERVER_TYPES.IRegistryExtensionService).to(RegistryExtensionService).inSingletonScope().whenTargetIsDefault();
-  // Extension Repository
-  bind(SERVER_TYPES.IRegistryExtensionRepository).to(RegistryExtensionRepository).inSingletonScope().whenTargetIsDefault();
+  // Installed Extension Service
+  bind(SERVER_TYPES.IInstalledExtensionService).to(InstalledExtensionServiceExt).inSingletonScope().whenTargetIsDefault();
+  // Installed Extension Repository
+  bind(SERVER_TYPES.IInstalledExtensionRepository).to(InstalledExtensionRepository).inSingletonScope().whenTargetIsDefault();
+  // Publisher Service
+  bind(SERVER_TYPES.IMarketplacePublisherService).to(MarketplacePublisherService).inSingletonScope().whenTargetIsDefault();
+  // Publisher Repository
+  bind(SERVER_TYPES.IMarketplacePublisherRepository).to(MarketplacePublisherRepository).inSingletonScope().whenTargetIsDefault();
+  // Publisher Event Service
+  bind(SERVER_TYPES.IPublisherEventService).to(PublisherEventService).inSingletonScope().whenTargetIsDefault();
+  // Extension Gallery Repository
+  bind(SERVER_TYPES.IExtensionGalleryRepository).to(ExtensionGalleryRepository).inSingletonScope().whenTargetIsDefault();
+  // Extension Gallery Service
+  bind(SERVER_TYPES.IExtensionGalleryService).to(ExtensionGalleryService).inSingletonScope().whenTargetIsDefault();
+  bind('MongodbMigration').to(DropOldPublisherNameIndexMigration).whenTargetNamed(DropOldPublisherNameIndexMigration.name);
 });export{extensionModule};//# sourceMappingURL=module.js.map

package/lib/containers/module.js.map

@@ -1 +1 @@
-{"version":3,"file":"module.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}
+{"version":3,"file":"module.js","sources":["../../src/containers/module.ts"],"sourcesContent":[null],"names":[],"mappings":";;;EA6EG,IAAA,CAAA,YAAA,CAAA,0BAAA,CAAA,CAAA,EAAA,CAAA,4BAAA,CAAA,CAAA,gBAAA,EAAA,CAAA,mBAAA,EAAA;AAEH;;;;;;;;;;;;;"}

package/lib/dataloaders/index.d.ts

@@ -0,0 +1,2 @@
+export * from './publisher-data-loader';
+//# sourceMappingURL=index.d.ts.map

package/lib/dataloaders/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dataloaders/index.ts"],"names":[],"mappings":"AACA,cAAc,yBAAyB,CAAC"}

package/lib/dataloaders/publisher-data-loader.d.ts

@@ -0,0 +1,6 @@
+import { IPublisherEventService, AsDomainType, IMarketplacePublisherModel } from 'common/server';
+import { BulkDataLoader2 } from '@common-stack/store-mongo';
+export declare class PublisherDataLoader extends BulkDataLoader2<AsDomainType<IMarketplacePublisherModel>> {
+    constructor(publisherService: IPublisherEventService);
+}
+//# sourceMappingURL=publisher-data-loader.d.ts.map

package/lib/dataloaders/publisher-data-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-data-loader.d.ts","sourceRoot":"","sources":["../../src/dataloaders/publisher-data-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,sBAAsB,EAGtB,YAAY,EACZ,0BAA0B,EAC7B,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,qBACa,mBAAoB,SAAQ,eAAe,CAAC,YAAY,CAAC,0BAA0B,CAAC,CAAC;gBAG1F,gBAAgB,EAAE,sBAAsB;CAI/C"}

package/lib/demo/test-graphql-examples.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Example GraphQL calls for testing the installExtension mutation
+ * with the new orgName parameter support
+ */
+declare const basicInstallExample: {
+    query: string;
+    variables: {
+        input: {
+            extensionSlug: string;
+            version: string;
+            settings: {
+                enabled: boolean;
+            };
+        };
+    };
+};
+declare const orgInstallExample: {
+    query: string;
+    variables: {
+        input: {
+            extensionSlug: string;
+            version: string;
+            orgName: string;
+            settings: {
+                enabled: boolean;
+                userConfig: {
+                    theme: string;
+                    notifications: boolean;
+                    autoSave: boolean;
+                };
+            };
+            policies: {
+                autoUpdate: boolean;
+                allowBeta: boolean;
+            };
+        };
+    };
+};
+declare const queryExtensionsExample: {
+    query: string;
+    variables: {
+        orgName: string;
+        enabled: boolean;
+    };
+};
+declare const expectedResponse: {
+    data: {
+        installExtension: {
+            success: boolean;
+            message: string;
+            extension: {
+                id: string;
+                status: string;
+                installedVersion: string;
+                extension: {
+                    extensionSlug: string;
+                    name: string;
+                    version: string;
+                };
+                settings: {
+                    effectiveEnabled: boolean;
+                    userConfig: {
+                        theme: string;
+                        notifications: boolean;
+                        autoSave: boolean;
+                    };
+                };
+            };
+        };
+    };
+};
+export { basicInstallExample, orgInstallExample, queryExtensionsExample, expectedResponse };
+//# sourceMappingURL=test-graphql-examples.d.ts.map

package/lib/demo/test-graphql-examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-graphql-examples.d.ts","sourceRoot":"","sources":["../../src/demo/test-graphql-examples.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,QAAA,MAAM,mBAAmB;;;;;;;;;;;CAgCxB,CAAC;AAQF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;CA0CtB,CAAC;AAOF,QAAA,MAAM,sBAAsB;;;;;;CAuB3B,CAAC;AAOF,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;CAyBrB,CAAC;AAqBF,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,CAAC"}

package/lib/graphql/resolvers/form-templates-resolver.d.ts

@@ -0,0 +1,220 @@
+type Context = {
+    user?: {
+        id: string;
+        name: string;
+        email: string;
+    };
+};
+type FormTemplatesInput = {
+    search?: string;
+    category?: string;
+    publisherId?: string;
+    installed?: boolean;
+    limit?: number;
+    offset?: number;
+};
+export declare const formTemplateResolvers: () => {
+    Query: {
+        marketplaceFormTemplates: (_: unknown, { input }: {
+            input?: FormTemplatesInput;
+        }, context: Context) => Promise<{
+            nodes: {
+                id: string;
+                name: string;
+                description: string;
+                category: string;
+                version: string;
+                author: string;
+                publisherId: string;
+                tags: string[];
+                schema: string;
+                uiSchema: string;
+                downloads: number;
+                rating: number;
+                reviewCount: number;
+                createdAt: Date;
+                updatedAt: Date;
+                installed: boolean;
+                preview: any;
+                publisher: {
+                    id: string;
+                    name: string;
+                    email: string;
+                };
+            }[];
+            totalCount: number;
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: string;
+                endCursor: string;
+            };
+        }>;
+        marketplaceFormTemplate: (_: unknown, { id }: {
+            id: string;
+        }, context: Context) => Promise<{
+            id: string;
+            name: string;
+            description: string;
+            category: string;
+            version: string;
+            author: string;
+            publisherId: string;
+            tags: string[];
+            schema: string;
+            uiSchema: string;
+            downloads: number;
+            rating: number;
+            reviewCount: number;
+            createdAt: Date;
+            updatedAt: Date;
+            installed: boolean;
+            preview: any;
+            publisher: {
+                id: string;
+                name: string;
+                email: string;
+            };
+        }>;
+        marketplaceInstalledFormTemplates: () => Promise<{
+            id: string;
+            name: string;
+            description: string;
+            category: string;
+            version: string;
+            author: string;
+            publisherId: string;
+            tags: string[];
+            schema: string;
+            uiSchema: string;
+            downloads: number;
+            rating: number;
+            reviewCount: number;
+            createdAt: Date;
+            updatedAt: Date;
+            installed: boolean;
+            preview: any;
+            publisher: {
+                id: string;
+                name: string;
+                email: string;
+            };
+        }[]>;
+        marketplaceMyFormTemplates: () => Promise<any[]>;
+        marketplacePopularFormTemplates: () => Promise<any[]>;
+        marketplaceRecentFormTemplates: () => Promise<any[]>;
+    };
+    Mutation: {
+        marketplacePublishFormTemplate: (_: unknown, { input }: {
+            input: unknown;
+        }, context: Context) => Promise<{
+            success: boolean;
+            message: string;
+            formTemplate: {
+                id: string;
+                name: string;
+                description: string;
+                category: string;
+                version: string;
+                author: string;
+                publisherId: string;
+                tags: string[];
+                schema: string;
+                uiSchema: string;
+                downloads: number;
+                rating: number;
+                reviewCount: number;
+                createdAt: Date;
+                updatedAt: Date;
+                installed: boolean;
+                preview: any;
+                publisher: {
+                    id: string;
+                    name: string;
+                    email: string;
+                };
+            };
+        }>;
+        marketplaceInstallFormTemplate: (_: unknown, { input }: {
+            input: {
+                id: string;
+            };
+        }, context: Context) => Promise<{
+            success: boolean;
+            message: string;
+            formTemplate: {
+                id: string;
+                name: string;
+                description: string;
+                category: string;
+                version: string;
+                author: string;
+                publisherId: string;
+                tags: string[];
+                schema: string;
+                uiSchema: string;
+                downloads: number;
+                rating: number;
+                reviewCount: number;
+                createdAt: Date;
+                updatedAt: Date;
+                installed: boolean;
+                preview: any;
+                publisher: {
+                    id: string;
+                    name: string;
+                    email: string;
+                };
+            };
+        }>;
+        marketplaceUninstallFormTemplate: () => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        marketplaceUpdateFormTemplate: () => Promise<{
+            success: boolean;
+            message: string;
+            formTemplate: {
+                id: string;
+                name: string;
+                description: string;
+                category: string;
+                version: string;
+                author: string;
+                publisherId: string;
+                tags: string[];
+                schema: string;
+                uiSchema: string;
+                downloads: number;
+                rating: number;
+                reviewCount: number;
+                createdAt: Date;
+                updatedAt: Date;
+                installed: boolean;
+                preview: any;
+                publisher: {
+                    id: string;
+                    name: string;
+                    email: string;
+                };
+            };
+        }>;
+        marketplaceDeleteFormTemplate: () => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        marketplaceRateFormTemplate: () => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+    };
+    Subscription: {
+        marketplaceFormTemplateEvents: {
+            subscribe: (_: unknown, { publisherId }: {
+                publisherId?: string;
+            }) => AsyncIterator<unknown, any, any>;
+        };
+    };
+};
+export {};
+//# sourceMappingURL=form-templates-resolver.d.ts.map

package/lib/graphql/resolvers/form-templates-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-templates-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/form-templates-resolver.ts"],"names":[],"mappings":"AAIA,KAAK,OAAO,GAAG;IACX,IAAI,CAAC,EAAE;QACH,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAwCF,eAAO,MAAM,qBAAqB;;sCAInB,OAAO,aACC;YAAE,KAAK,CAAC,EAAE,kBAAkB,CAAA;SAAE,WAEhC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAsCb,OAAO,UACF;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,WAEb,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAeb,OAAO,aAEC;YAAE,KAAK,EAAE,OAAO,CAAA;SAAE,WAEpB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CA4Bb,OAAO,aACC;YAAE,KAAK,EAAE;gBAAE,EAAE,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,WAE3B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiCT,OAAO,mBACO;gBAAE,WAAW,CAAC,EAAE,MAAM,CAAA;aAAE;;;CASvD,CAAC"}