@idevconn/create-icore 0.7.2 → 0.8.0

package/templates/libs/db-strategies/mongodb/src/lib/mongodb-db.module.ts

@@ -0,0 +1,41 @@
+import { Module, DynamicModule } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { MongooseModule, getConnectionToken } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+import { buildStrategyWithFallback, FakeDBStrategy } from '@icore/shared';
+import type { DBStrategy } from '@icore/shared';
+import { MongoDbDBStrategy } from './mongodb-db.strategy';
+
+export const MONGODB_DB_REQUIRED_ENV = ['MONGODB_URI'];
+
+@Module({})
+export class MongoDbDbModule {
+  static forRoot(envPath: string): DynamicModule {
+    return {
+      module: MongoDbDbModule,
+      imports: [
+        MongooseModule.forRootAsync({
+          useFactory: (cfg: ConfigService) => ({ uri: cfg.get<string>('MONGODB_URI') }),
+          inject: [ConfigService],
+        }),
+      ],
+      providers: [
+        {
+          provide: 'DBStrategy',
+          useFactory: (cfg: ConfigService, connection: Connection): DBStrategy =>
+            buildStrategyWithFallback<DBStrategy>({
+              service: 'notes MS',
+              provider: 'mongodb',
+              requiredEnv: MONGODB_DB_REQUIRED_ENV,
+              cfg,
+              envPath,
+              build: () => new MongoDbDBStrategy({ connection }),
+              fake: () => new FakeDBStrategy(),
+            }),
+          inject: [ConfigService, getConnectionToken()],
+        },
+      ],
+      exports: ['DBStrategy'],
+    };
+  }
+}

package/templates/libs/db-strategies/mongodb/tsconfig.json

@@ -2,6 +2,8 @@
   "extends": "../../../tsconfig.base.json",
   "compilerOptions": {
     "module": "commonjs",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "importHelpers": true,

package/templates/libs/db-strategies/supabase/eslint.config.mjs

@@ -12,7 +12,12 @@ export default [
             '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
             '{projectRoot}/vitest.config.{js,ts,mjs,mts}',
           ],
-          ignoredDependencies: ['@icore/shared', '@supabase/supabase-js'],
+          ignoredDependencies: [
+            '@icore/shared',
+            '@supabase/supabase-js',
+            '@nestjs/testing',
+            'vitest',
+          ],
         },
       ],
     },

package/templates/libs/db-strategies/supabase/package.json

@@ -7,10 +7,13 @@
   "types": "./src/index.ts",
   "dependencies": {
     "@icore/shared": "*",
+    "@nestjs/common": "^11.1.24",
+    "@nestjs/config": "^4.0.4",
     "@supabase/supabase-js": "^2.0.0",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
+    "@nestjs/testing": "^11.0.0",
     "vitest": "^4.0.0"
   }
 }

package/templates/libs/db-strategies/supabase/src/index.ts

@@ -1,2 +1,3 @@
 export * from './lib/supabase-db.strategy';
 export * from './lib/testing/mock-supabase-postgres';
+export * from './lib/supabase-db.module';

package/templates/libs/db-strategies/supabase/src/lib/__tests__/supabase-db.module.unit.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { Global, Module } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import { SupabaseDbModule, SUPABASE_DB_REQUIRED_ENV } from '../supabase-db.module.js';
+import { SupabaseDBStrategy } from '../supabase-db.strategy.js';
+
+let ENV: Record<string, string | undefined> = {};
+@Global()
+@Module({
+  providers: [
+    {
+      provide: ConfigService,
+      useValue: { get: (k: string) => ENV[k], getOrThrow: (k: string) => ENV[k] },
+    },
+  ],
+  exports: [ConfigService],
+})
+class StubConfigModule {}
+
+describe('SupabaseDbModule', () => {
+  it('declares its required env', () => {
+    expect(SUPABASE_DB_REQUIRED_ENV).toEqual(['SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY']);
+  });
+  it('provides a real SupabaseDBStrategy under DBStrategy when env present', async () => {
+    ENV = { SUPABASE_URL: 'https://x.supabase.co', SUPABASE_SERVICE_ROLE_KEY: 'svc' };
+    const ref = await Test.createTestingModule({
+      imports: [StubConfigModule, SupabaseDbModule.forRoot('.env')],
+    }).compile();
+    expect(ref.get('DBStrategy')).toBeInstanceOf(SupabaseDBStrategy);
+  });
+});

package/templates/libs/db-strategies/supabase/src/lib/supabase-db.module.ts

@@ -0,0 +1,41 @@
+import { Module, DynamicModule } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { createClient } from '@supabase/supabase-js';
+import { buildStrategyWithFallback, FakeDBStrategy } from '@icore/shared';
+import type { DBStrategy } from '@icore/shared';
+import { SupabaseDBStrategy } from './supabase-db.strategy';
+
+export const SUPABASE_DB_REQUIRED_ENV = ['SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY'];
+
+@Module({})
+export class SupabaseDbModule {
+  static forRoot(envPath: string): DynamicModule {
+    return {
+      module: SupabaseDbModule,
+      providers: [
+        {
+          provide: 'DBStrategy',
+          useFactory: (cfg: ConfigService): DBStrategy =>
+            buildStrategyWithFallback<DBStrategy>({
+              service: 'notes MS',
+              provider: 'supabase',
+              requiredEnv: SUPABASE_DB_REQUIRED_ENV,
+              cfg,
+              envPath,
+              build: () =>
+                new SupabaseDBStrategy({
+                  client: createClient(
+                    cfg.getOrThrow<string>('SUPABASE_URL'),
+                    cfg.getOrThrow<string>('SUPABASE_SERVICE_ROLE_KEY'),
+                    { auth: { autoRefreshToken: false, persistSession: false } },
+                  ),
+                }),
+              fake: () => new FakeDBStrategy(),
+            }),
+          inject: [ConfigService],
+        },
+      ],
+      exports: ['DBStrategy'],
+    };
+  }
+}

package/templates/libs/db-strategies/supabase/tsconfig.json

@@ -3,6 +3,8 @@
   "compilerOptions": {
     "module": "node16",
     "moduleResolution": "node16",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "importHelpers": true,

package/templates/libs/shared/src/strategies/__tests__/provide-strategy.unit.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { buildStrategyWithFallback } from '../provide-strategy.js';
+
+const cfgFrom = (env: Record<string, string | undefined>) => ({
+  get: (k: string) => env[k],
+});
+
+afterEach(() => {
+  delete process.env.NODE_ENV;
+  vi.restoreAllMocks();
+});
+
+describe('buildStrategyWithFallback', () => {
+  it('returns the built strategy when all required env is present', () => {
+    const result = buildStrategyWithFallback({
+      service: 'auth MS',
+      provider: 'supabase',
+      requiredEnv: ['A', 'B'],
+      cfg: cfgFrom({ A: '1', B: '2' }),
+      envPath: '.env',
+      build: () => 'REAL',
+      fake: () => 'FAKE',
+    });
+    expect(result).toBe('REAL');
+  });
+
+  it('returns the fake (dev) when required env is missing', () => {
+    process.env.NODE_ENV = 'development';
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    const result = buildStrategyWithFallback({
+      service: 'auth MS',
+      provider: 'supabase',
+      requiredEnv: ['A', 'B'],
+      cfg: cfgFrom({ A: '1' }),
+      envPath: '.env',
+      build: () => 'REAL',
+      fake: () => 'FAKE',
+    });
+    expect(result).toBe('FAKE');
+  });
+
+  it('throws (prod) when required env is missing', () => {
+    process.env.NODE_ENV = 'production';
+    expect(() =>
+      buildStrategyWithFallback({
+        service: 'auth MS',
+        provider: 'supabase',
+        requiredEnv: ['A', 'B'],
+        cfg: cfgFrom({}),
+        envPath: '.env',
+        build: () => 'REAL',
+        fake: () => 'FAKE',
+      }),
+    ).toThrow();
+  });
+
+  it('falls back when build() throws despite present env', () => {
+    process.env.NODE_ENV = 'development';
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    const result = buildStrategyWithFallback({
+      service: 'auth MS',
+      provider: 'supabase',
+      requiredEnv: ['A'],
+      cfg: cfgFrom({ A: '1' }),
+      envPath: '.env',
+      build: () => {
+        throw new Error('bad url');
+      },
+      fake: () => 'FAKE',
+    });
+    expect(result).toBe('FAKE');
+  });
+});

package/templates/libs/shared/src/strategies/index.ts

@@ -2,6 +2,7 @@ export * from './auth';
 export * from './storage';
 export * from './db';
 export * from './fakes';
+export * from './provide-strategy';
 // NOTE: the strategy contract harness (runAuthContract / runStorageContract /
 // runDBContract) is intentionally NOT exported here — it is test-only code and
 // lives behind the '@icore/shared/testing' entry. See ../testing.ts.

package/templates/libs/shared/src/strategies/provide-strategy.ts

@@ -0,0 +1,44 @@
+import { missingEnv, formatEnvBanner } from '../env';
+
+export interface StrategyConfigReader {
+  get(key: string): string | undefined;
+}
+
+export interface BuildStrategyOpts<T> {
+  service: string;
+  provider: string;
+  requiredEnv: string[];
+  cfg: StrategyConfigReader;
+  envPath: string;
+  build: () => T;
+  fake: () => T;
+}
+
+/**
+ * Build a concrete strategy, or fall back to the in-memory fake. Centralises the
+ * dev-warns-and-fakes / prod-fails-fast behavior that used to live inline in each
+ * microservice app.module useFactory.
+ */
+export function buildStrategyWithFallback<T>(opts: BuildStrategyOpts<T>): T {
+  const missing = missingEnv((k) => opts.cfg.get(k), opts.requiredEnv);
+
+  const fallback = (reason?: string): T => {
+    const banner = formatEnvBanner({
+      service: opts.service,
+      provider: opts.provider,
+      missing,
+      envPath: opts.envPath,
+      reason,
+    });
+    if (process.env['NODE_ENV'] === 'production') throw new Error(banner);
+    console.warn(banner);
+    return opts.fake();
+  };
+
+  if (missing.length > 0) return fallback();
+  try {
+    return opts.build();
+  } catch (err) {
+    return fallback(err instanceof Error ? err.message : String(err));
+  }
+}

package/templates/libs/storage-strategies/cloudinary/eslint.config.mjs

@@ -12,7 +12,7 @@ export default [
             '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
             '{projectRoot}/vitest.config.{js,ts,mjs,mts}',
           ],
-          ignoredDependencies: ['@icore/shared'],
+          ignoredDependencies: ['@icore/shared', '@nestjs/testing', 'vitest'],
         },
       ],
     },

package/templates/libs/storage-strategies/cloudinary/package.json

@@ -7,9 +7,13 @@
   "types": "./src/index.ts",
   "dependencies": {
     "@icore/shared": "*",
+    "@nestjs/common": "^11.1.24",
+    "@nestjs/config": "^4.0.4",
+    "cloudinary": "^2.10.0",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
+    "@nestjs/testing": "^11.0.0",
     "vitest": "^4.0.0"
   }
 }

package/templates/libs/storage-strategies/cloudinary/src/index.ts

@@ -1,2 +1,3 @@
 export * from './lib/cloudinary-storage.strategy.js';
 export * from './lib/testing/mock-cloudinary.js';
+export * from './lib/cloudinary-storage.module.js';

package/templates/libs/storage-strategies/cloudinary/src/lib/__tests__/cloudinary-storage.module.unit.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { Global, Module } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import {
+  CloudinaryStorageModule,
+  CLOUDINARY_STORAGE_REQUIRED_ENV,
+} from '../cloudinary-storage.module.js';
+import { CloudinaryStorageStrategy } from '../cloudinary-storage.strategy.js';
+
+let ENV: Record<string, string | undefined> = {};
+@Global()
+@Module({
+  providers: [
+    {
+      provide: ConfigService,
+      useValue: { get: (k: string) => ENV[k], getOrThrow: (k: string) => ENV[k] },
+    },
+  ],
+  exports: [ConfigService],
+})
+class StubConfigModule {}
+
+describe('CloudinaryStorageModule', () => {
+  it('declares its required env', () => {
+    expect(CLOUDINARY_STORAGE_REQUIRED_ENV).toEqual([
+      'CLOUDINARY_CLOUD_NAME',
+      'CLOUDINARY_API_KEY',
+      'CLOUDINARY_API_SECRET',
+    ]);
+  });
+
+  it('provides a real CloudinaryStorageStrategy when env present', async () => {
+    ENV = { CLOUDINARY_CLOUD_NAME: 'c', CLOUDINARY_API_KEY: 'k', CLOUDINARY_API_SECRET: 's' };
+    const ref = await Test.createTestingModule({
+      imports: [StubConfigModule, CloudinaryStorageModule.forRoot('.env')],
+    }).compile();
+    expect(ref.get('StorageStrategy')).toBeInstanceOf(CloudinaryStorageStrategy);
+  });
+});

package/templates/libs/storage-strategies/cloudinary/src/lib/cloudinary-storage.module.ts

@@ -0,0 +1,85 @@
+import { Module, DynamicModule } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { v2 as cloudinary } from 'cloudinary';
+import { buildStrategyWithFallback, FakeStorageStrategy } from '@icore/shared';
+import type { StorageStrategy } from '@icore/shared';
+import { CloudinaryStorageStrategy, type CloudinaryApiLike } from './cloudinary-storage.strategy';
+
+export const CLOUDINARY_STORAGE_REQUIRED_ENV = [
+  'CLOUDINARY_CLOUD_NAME',
+  'CLOUDINARY_API_KEY',
+  'CLOUDINARY_API_SECRET',
+];
+
+@Module({})
+export class CloudinaryStorageModule {
+  static forRoot(envPath: string): DynamicModule {
+    return {
+      module: CloudinaryStorageModule,
+      providers: [
+        {
+          provide: 'StorageStrategy',
+          useFactory: (cfg: ConfigService): StorageStrategy =>
+            buildStrategyWithFallback<StorageStrategy>({
+              service: 'upload MS',
+              provider: 'cloudinary',
+              requiredEnv: CLOUDINARY_STORAGE_REQUIRED_ENV,
+              cfg,
+              envPath,
+              build: () => {
+                cloudinary.config({
+                  cloud_name: cfg.getOrThrow<string>('CLOUDINARY_CLOUD_NAME'),
+                  api_key: cfg.getOrThrow<string>('CLOUDINARY_API_KEY'),
+                  api_secret: cfg.getOrThrow<string>('CLOUDINARY_API_SECRET'),
+                  secure: true,
+                });
+                const api: CloudinaryApiLike = {
+                  async upload(buffer, opts) {
+                    return new Promise((resolve, reject) => {
+                      const stream = cloudinary.uploader.upload_stream(
+                        { public_id: opts.public_id, resource_type: opts.resource_type ?? 'raw' },
+                        (error, result) => {
+                          if (error || !result) reject(error ?? new Error('upload_failed'));
+                          else
+                            resolve({ public_id: result.public_id, secure_url: result.secure_url });
+                        },
+                      );
+                      stream.end(buffer);
+                    });
+                  },
+                  async destroy(publicId) {
+                    await cloudinary.uploader.destroy(publicId);
+                  },
+                  privateDownloadUrl(publicId, format, opts) {
+                    return cloudinary.utils.private_download_url(
+                      publicId,
+                      format ?? '',
+                      opts ?? {},
+                    );
+                  },
+                  async resources(opts) {
+                    const res = await cloudinary.api.resources({
+                      prefix: opts.prefix,
+                      type: opts.type ?? 'upload',
+                    });
+                    return {
+                      resources: (res.resources ?? []).map((r: { public_id: string }) => ({
+                        public_id: r.public_id,
+                      })),
+                    };
+                  },
+                };
+                return new CloudinaryStorageStrategy({
+                  api,
+                  bucket: cfg.get<string>('CLOUDINARY_BUCKET_TAG') ?? 'cloudinary',
+                });
+              },
+              fake: () => new FakeStorageStrategy(),
+            }),
+          inject: [ConfigService],
+        },
+      ],
+      exports: ['StorageStrategy'],
+    };
+  }
+}

package/templates/libs/storage-strategies/cloudinary/tsconfig.json

@@ -3,6 +3,8 @@
   "compilerOptions": {
     "module": "node16",
     "moduleResolution": "node16",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "importHelpers": true,

package/templates/libs/storage-strategies/firebase/eslint.config.mjs

@@ -12,7 +12,7 @@ export default [
             '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
             '{projectRoot}/vitest.config.{js,ts,mjs,mts}',
           ],
-          ignoredDependencies: ['@icore/shared'],
+          ignoredDependencies: ['@icore/shared', '@nestjs/testing', 'vitest'],
         },
       ],
     },

package/templates/libs/storage-strategies/firebase/package.json

@@ -6,10 +6,14 @@
   "main": "./src/index.js",
   "types": "./src/index.ts",
   "dependencies": {
+    "@icore/firebase-admin": "*",
     "@icore/shared": "*",
+    "@nestjs/common": "^11.1.24",
+    "@nestjs/config": "^4.0.4",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
+    "@nestjs/testing": "^11.0.0",
     "vitest": "^4.0.0"
   }
 }

package/templates/libs/storage-strategies/firebase/src/index.ts

@@ -1,2 +1,3 @@
 export * from './lib/firebase-storage.strategy.js';
 export * from './lib/testing/mock-firebase-storage.js';
+export * from './lib/firebase-storage.module.js';

package/templates/libs/storage-strategies/firebase/src/lib/__tests__/firebase-storage.module.unit.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Global, Module } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import {
+  FirebaseStorageModule,
+  FIREBASE_STORAGE_REQUIRED_ENV,
+} from '../firebase-storage.module.js';
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: ConfigService,
+      useValue: {
+        get: () => undefined,
+        getOrThrow: () => {
+          throw new Error('missing');
+        },
+      },
+    },
+  ],
+  exports: [ConfigService],
+})
+class StubConfigModule {}
+
+describe('FirebaseStorageModule', () => {
+  it('requires firebase-admin env + the storage bucket', () => {
+    expect(FIREBASE_STORAGE_REQUIRED_ENV).toContain('FIREBASE_STORAGE_BUCKET');
+    expect(FIREBASE_STORAGE_REQUIRED_ENV).toContain('FB_ADMIN_PROJECT_ID');
+  });
+
+  it('falls back to the fake (dev) when env is missing, without touching firebase-admin', async () => {
+    process.env.NODE_ENV = 'development';
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    const ref = await Test.createTestingModule({
+      imports: [StubConfigModule, FirebaseStorageModule.forRoot('.env')],
+    }).compile();
+    expect(typeof (ref.get('StorageStrategy') as { upload: unknown }).upload).toBe('function');
+    delete process.env.NODE_ENV;
+  });
+});

package/templates/libs/storage-strategies/firebase/src/lib/firebase-storage.module.ts

@@ -0,0 +1,46 @@
+import { Module, DynamicModule } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { getFirebaseAdmin, FIREBASE_ADMIN_REQUIRED_ENV } from '@icore/firebase-admin';
+import { buildStrategyWithFallback, FakeStorageStrategy } from '@icore/shared';
+import type { StorageStrategy } from '@icore/shared';
+import {
+  FirebaseStorageStrategy,
+  type FirebaseStorageBucketLike,
+} from './firebase-storage.strategy';
+
+export const FIREBASE_STORAGE_REQUIRED_ENV = [
+  ...FIREBASE_ADMIN_REQUIRED_ENV,
+  'FIREBASE_STORAGE_BUCKET',
+];
+
+@Module({})
+export class FirebaseStorageModule {
+  static forRoot(envPath: string): DynamicModule {
+    return {
+      module: FirebaseStorageModule,
+      providers: [
+        {
+          provide: 'StorageStrategy',
+          useFactory: (cfg: ConfigService): StorageStrategy =>
+            buildStrategyWithFallback<StorageStrategy>({
+              service: 'upload MS',
+              provider: 'firebase',
+              requiredEnv: FIREBASE_STORAGE_REQUIRED_ENV,
+              cfg,
+              envPath,
+              build: () => {
+                const bucketName = cfg.getOrThrow<string>('FIREBASE_STORAGE_BUCKET');
+                const app = getFirebaseAdmin(cfg);
+                return new FirebaseStorageStrategy({
+                  bucket: app.storage().bucket(bucketName) as unknown as FirebaseStorageBucketLike,
+                });
+              },
+              fake: () => new FakeStorageStrategy(),
+            }),
+          inject: [ConfigService],
+        },
+      ],
+      exports: ['StorageStrategy'],
+    };
+  }
+}

package/templates/libs/storage-strategies/firebase/tsconfig.json

@@ -3,6 +3,8 @@
   "compilerOptions": {
     "module": "node16",
     "moduleResolution": "node16",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "importHelpers": true,

package/templates/libs/storage-strategies/mongodb/package.json

@@ -6,7 +6,10 @@
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "dependencies": {
-    "@icore/shared": "workspace:*",
+    "@icore/shared": "*",
+    "@nestjs/common": "^11.1.24",
+    "@nestjs/config": "^4.0.4",
+    "@nestjs/mongoose": "^11.0.4",
     "mongodb-memory-server": "^11.2.0",
     "mongoose": "^9.6.3",
     "tslib": "^2.3.0"

package/templates/libs/storage-strategies/mongodb/src/index.ts

@@ -1 +1,2 @@
 export * from './lib/mongodb-storage.strategy';
+export * from './lib/mongodb-storage.module';

package/templates/libs/storage-strategies/mongodb/src/lib/__tests__/mongodb-storage.module.unit.test.ts

@@ -0,0 +1,14 @@
+import { MongoDbStorageModule, MONGODB_STORAGE_REQUIRED_ENV } from '../mongodb-storage.module';
+
+describe('MongoDbStorageModule', () => {
+  it('requires the mongo uri', () => {
+    expect(MONGODB_STORAGE_REQUIRED_ENV).toEqual(['MONGODB_URI']);
+  });
+  it('forRoot returns a DynamicModule importing Mongoose and exporting StorageStrategy', () => {
+    const dm = MongoDbStorageModule.forRoot('.env');
+    expect(dm.module).toBe(MongoDbStorageModule);
+    expect(dm.exports).toContain('StorageStrategy');
+    expect(Array.isArray(dm.imports)).toBe(true);
+    expect((dm.imports ?? []).length).toBeGreaterThan(0);
+  });
+});