@idevconn/create-icore 0.6.3 → 0.7.1

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

@@ -0,0 +1,19 @@
+import baseConfig from '../../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}'],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/templates/libs/db-strategies/mongodb/jest.config.cts

@@ -0,0 +1,10 @@
+module.exports = {
+  displayName: 'mongodb',
+  preset: '../../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../../coverage/libs/db-strategies/mongodb',
+};

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

@@ -0,0 +1,14 @@
+{
+  "name": "@icore/db-mongodb",
+  "version": "0.0.2",
+  "private": true,
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "@icore/shared": "workspace:*",
+    "mongodb-memory-server": "^11.2.0",
+    "mongoose": "^9.6.3",
+    "tslib": "^2.3.0"
+  }
+}

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

@@ -0,0 +1,19 @@
+{
+  "name": "db-mongodb",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/db-strategies/mongodb/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/db-strategies/mongodb",
+        "main": "libs/db-strategies/mongodb/src/index.ts",
+        "tsConfig": "libs/db-strategies/mongodb/tsconfig.lib.json",
+        "assets": ["libs/db-strategies/mongodb/*.md"]
+      }
+    }
+  }
+}

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

@@ -0,0 +1 @@
+export * from './lib/mongodb-db.strategy';

package/templates/libs/db-strategies/mongodb/src/lib/__tests__/mongodb-db.strategy.unit.test.ts

@@ -0,0 +1,38 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { connect, Connection } from 'mongoose';
+import { MongoDbDBStrategy } from '../mongodb-db.strategy';
+import { runDBContract } from '@icore/shared/testing';
+
+describe('MongoDbDBStrategy', () => {
+  let mongod: MongoMemoryServer;
+  let connection: Connection;
+  let strategy: MongoDbDBStrategy;
+
+  beforeAll(async () => {
+    mongod = await MongoMemoryServer.create();
+    const uri = mongod.getUri();
+    const conn = await connect(uri);
+    connection = conn.connection;
+  }, 30000);
+
+  afterAll(async () => {
+    if (connection) await connection.close();
+    if (mongod) await mongod.stop();
+  });
+
+  beforeEach(async () => {
+    if (connection.db) {
+      const collections = await connection.db.collections();
+      for (const collection of collections) {
+        await collection.deleteMany({});
+      }
+    }
+  });
+
+  runDBContract('mongodb', () => {
+    if (!strategy) {
+      strategy = new MongoDbDBStrategy({ connection });
+    }
+    return strategy;
+  });
+});

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

@@ -0,0 +1,108 @@
+import { Connection, Model, Schema } from 'mongoose';
+import { DBStrategy, DBDocument, QueryOptions } from '@icore/shared';
+
+export interface MongoDbDBStrategyOptions {
+  connection: Connection;
+}
+
+export class MongoDbDBStrategy implements DBStrategy {
+  private models: Map<string, Model<unknown>> = new Map();
+
+  constructor(private readonly opts: MongoDbDBStrategyOptions) {}
+
+  private getModel(collection: string): Model<{ id: string; data: unknown }> {
+    if (!this.models.has(collection)) {
+      const schema = new Schema(
+        {
+          id: { type: String, required: true, index: true },
+          data: { type: Schema.Types.Mixed, required: true },
+        },
+        { strict: false, timestamps: true },
+      );
+      const model = this.opts.connection.model(collection, schema);
+      this.models.set(collection, model);
+      return model;
+    }
+    return this.models.get(collection) as Model<{ id: string; data: unknown }>;
+  }
+
+  async get<T>(collection: string, id: string): Promise<DBDocument<T> | null> {
+    const model = this.getModel(collection);
+    const doc = await model.findOne({ id }).lean().exec();
+    if (!doc) return null;
+    return { id: doc.id, data: doc.data as T };
+  }
+
+  async set<T>(collection: string, id: string, data: T): Promise<void> {
+    const model = this.getModel(collection);
+    await model.findOneAndUpdate({ id }, { id, data }, { upsert: true }).exec();
+  }
+
+  async update<T>(collection: string, id: string, patch: Partial<T>): Promise<void> {
+    const model = this.getModel(collection);
+    // Use dot notation for partial updates of the 'data' field
+    const update: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(patch)) {
+      update[`data.${key}`] = value;
+    }
+    const result = await model.findOneAndUpdate({ id }, { $set: update }).exec();
+    if (!result) throw new Error(`not_found: ${collection}/${id}`);
+  }
+
+  async delete(collection: string, id: string): Promise<void> {
+    const model = this.getModel(collection);
+    const result = await model.findOneAndDelete({ id }).exec();
+    if (!result) throw new Error(`not_found: ${collection}/${id}`);
+  }
+
+  async list<T>(collection: string, opts?: QueryOptions): Promise<DBDocument<T>[]> {
+    const model = this.getModel(collection);
+    let q = model.find();
+
+    if (opts?.where) {
+      const filter: Record<string, unknown> = {};
+      for (const c of opts.where) {
+        const path = c.field === 'id' ? 'id' : `data.${c.field}`;
+        switch (c.op) {
+          case '==':
+            filter[path] = c.value;
+            break;
+          case '!=':
+            filter[path] = { $ne: c.value };
+            break;
+          case '<':
+            filter[path] = { $lt: c.value };
+            break;
+          case '<=':
+            filter[path] = { $lte: c.value };
+            break;
+          case '>':
+            filter[path] = { $gt: c.value };
+            break;
+          case '>=':
+            filter[path] = { $gte: c.value };
+            break;
+          case 'in':
+            filter[path] = { $in: c.value };
+            break;
+        }
+      }
+      q = q.where(filter);
+    }
+
+    if (opts?.orderBy) {
+      const field = opts.orderBy.field === 'id' ? 'id' : `data.${opts.orderBy.field}`;
+      q = q.sort({ [field]: opts.orderBy.direction === 'desc' ? -1 : 1 });
+    }
+
+    if (opts?.limit != null) {
+      q = q.limit(opts.limit);
+    }
+
+    const docs = await q.lean().exec();
+    return docs.map((doc) => ({
+      id: (doc as { id: string }).id,
+      data: (doc as { data: T }).data,
+    }));
+  }
+}

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

@@ -0,0 +1,7 @@
+import { mongodb } from './mongodb';
+
+describe('mongodb', () => {
+  it('should work', () => {
+    expect(mongodb()).toEqual('mongodb');
+  });
+});

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

@@ -0,0 +1,3 @@
+export function mongodb(): string {
+  return 'mongodb';
+}

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

@@ -0,0 +1,23 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

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

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "jest.config.cts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

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

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "jest.config.cts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}

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

@@ -14,4 +14,7 @@ export interface StorageStrategy {
   remove(userId: string, ref: StorageRef): Promise<void>;
   getSignedUrl(userId: string, ref: StorageRef, ttlSec?: number): Promise<string>;
   list(userId: string, prefix?: string): Promise<StorageRef[]>;
+  /** Providers that can't issue real signed URLs (e.g. GridFS) implement this
+   *  so the gateway can proxy the file. Returns undefined for other providers. */
+  downloadBuffer?(userId: string, ref: StorageRef): Promise<Buffer>;
 }

package/templates/libs/storage-strategies/mongodb/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @icore/storage-mongodb
+
+## 0.0.2
+
+### Patch Changes
+
+- 2c29eac: Fix ESLint issues, update dependencies, and add MongoDB configuration examples to .env templates.
+- af27cae: Fix MongoDB review bugs and wire GridFS download: guard model re-registration, fix expiresIn calculation, escape regex in list(), replace `as never` cast, drop non-existent uuid v14 dep. Add downloadBuffer to StorageStrategy interface + MongoDbStorageStrategy impl + upload MS handler + UploadClientService method + GET /api/storage/file gateway endpoint so MongoDB storage downloads actually work.

package/templates/libs/storage-strategies/mongodb/README.md

@@ -0,0 +1,11 @@
+# storage-mongodb
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build storage-mongodb` to build the library.
+
+## Running unit tests
+
+Run `nx test storage-mongodb` to execute the unit tests via [Jest](https://jestjs.io).

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

@@ -0,0 +1,19 @@
+import baseConfig from '../../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}'],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/templates/libs/storage-strategies/mongodb/jest.config.cts

@@ -0,0 +1,10 @@
+module.exports = {
+  displayName: 'storage-mongodb',
+  preset: '../../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../../coverage/libs/storage-strategies/mongodb',
+};

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

@@ -0,0 +1,14 @@
+{
+  "name": "@icore/storage-mongodb",
+  "version": "0.0.2",
+  "private": true,
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "@icore/shared": "workspace:*",
+    "mongodb-memory-server": "^11.2.0",
+    "mongoose": "^9.6.3",
+    "tslib": "^2.3.0"
+  }
+}

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

@@ -0,0 +1,19 @@
+{
+  "name": "storage-mongodb",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/storage-strategies/mongodb/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/storage-strategies/mongodb",
+        "main": "libs/storage-strategies/mongodb/src/index.ts",
+        "tsConfig": "libs/storage-strategies/mongodb/tsconfig.lib.json",
+        "assets": ["libs/storage-strategies/mongodb/*.md"]
+      }
+    }
+  }
+}

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

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

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

@@ -0,0 +1,38 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { connect, Connection } from 'mongoose';
+import { MongoDbStorageStrategy } from '../mongodb-storage.strategy';
+import { runStorageContract } from '@icore/shared/testing';
+
+describe('MongoDbStorageStrategy', () => {
+  let mongod: MongoMemoryServer;
+  let connection: Connection;
+  let strategy: MongoDbStorageStrategy;
+
+  beforeAll(async () => {
+    mongod = await MongoMemoryServer.create();
+    const uri = mongod.getUri();
+    const conn = await connect(uri);
+    connection = conn.connection;
+  }, 30000);
+
+  afterAll(async () => {
+    if (connection) await connection.close();
+    if (mongod) await mongod.stop();
+  });
+
+  beforeEach(async () => {
+    if (connection.db) {
+      const collections = await connection.db.collections();
+      for (const collection of collections) {
+        await collection.deleteMany({});
+      }
+    }
+  });
+
+  runStorageContract('mongodb', () => {
+    if (!strategy) {
+      strategy = new MongoDbStorageStrategy({ connection });
+    }
+    return strategy;
+  });
+});

package/templates/libs/storage-strategies/mongodb/src/lib/mongodb-storage.strategy.ts

@@ -0,0 +1,93 @@
+import { Connection, mongo } from 'mongoose';
+import { Readable } from 'node:stream';
+import { StorageStrategy, StorageRef, FileInput } from '@icore/shared';
+
+export interface MongoDbStorageStrategyOptions {
+  connection: Connection;
+  bucketName?: string;
+}
+
+export class MongoDbStorageStrategy implements StorageStrategy {
+  private bucket: mongo.GridFSBucket;
+
+  constructor(private readonly opts: MongoDbStorageStrategyOptions) {
+    this.bucket = new mongo.GridFSBucket(this.opts.connection.db as unknown as mongo.Db, {
+      bucketName: this.opts.bucketName || 'uploads',
+    });
+  }
+
+  async upload(userId: string, file: FileInput): Promise<StorageRef> {
+    const path = `${userId}/${file.filename}`;
+    const bucket = 'uploads';
+    const filename = `${bucket}/${path}`;
+    const uploadStream = this.bucket.openUploadStream(filename, {
+      metadata: { bucket, path, userId, contentType: file.mimeType },
+    });
+
+    return new Promise((resolve, reject) => {
+      const readable = new Readable();
+      readable.push(file.buffer);
+      readable.push(null);
+      readable
+        .pipe(uploadStream)
+        .on('error', reject)
+        .on('finish', () => resolve({ bucket, path }));
+    });
+  }
+
+  async remove(userId: string, ref: StorageRef): Promise<void> {
+    if (!ref.path.startsWith(`${userId}/`)) {
+      throw new Error('forbidden: ownership_mismatch');
+    }
+    const filename = `${ref.bucket}/${ref.path}`;
+    const files = await this.bucket.find({ filename }).toArray();
+    if (files.length === 0) throw new Error(`not_found: ${filename}`);
+
+    for (const file of files) {
+      await this.bucket.delete(file._id);
+    }
+  }
+
+  async getSignedUrl(userId: string, ref: StorageRef, _ttlSeconds?: number): Promise<string> {
+    if (!ref.path.startsWith(`${userId}/`)) {
+      throw new Error('forbidden: ownership_mismatch');
+    }
+    // In GridFS, we don't have built-in signed URLs like S3.
+    // For iCore, we proxy GridFS through the Gateway.
+    return `/api/storage/file?bucket=${ref.bucket}&path=${ref.path}`;
+  }
+
+  async list(userId: string, prefix?: string): Promise<StorageRef[]> {
+    const userPrefix = prefix ? `${userId}/${prefix}` : `${userId}/`;
+    const query: Record<string, unknown> = {
+      'metadata.userId': userId,
+      'metadata.path': new RegExp('^' + userPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')),
+    };
+
+    const files = await this.bucket.find(query).toArray();
+    return files.map((file) => ({
+      bucket: file.metadata?.['bucket'],
+      path: file.metadata?.['path'],
+    }));
+  }
+
+  async downloadBuffer(userId: string, ref: StorageRef): Promise<Buffer> {
+    if (!ref.path.startsWith(`${userId}/`)) {
+      throw new Error('forbidden: ownership_mismatch');
+    }
+    const filename = `${ref.bucket}/${ref.path}`;
+    const files = await this.bucket.find({ filename }).toArray();
+    if (files.length === 0) throw new Error(`not_found: ${filename}`);
+
+    const fileId = files[0]?._id;
+    if (!fileId) throw new Error('not_found');
+
+    const stream = this.bucket.openDownloadStream(fileId as never);
+    return new Promise<Buffer>((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      stream.on('data', (c: Buffer) => chunks.push(c));
+      stream.on('end', () => resolve(Buffer.concat(chunks)));
+      stream.on('error', reject);
+    });
+  }
+}

package/templates/libs/storage-strategies/mongodb/src/lib/storage-mongodb.spec.ts

@@ -0,0 +1,7 @@
+import { storageMongodb } from './storage-mongodb';
+
+describe('storageMongodb', () => {
+  it('should work', () => {
+    expect(storageMongodb()).toEqual('storage-mongodb');
+  });
+});

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

@@ -0,0 +1,3 @@
+export function storageMongodb(): string {
+  return 'storage-mongodb';
+}

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

@@ -0,0 +1,23 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

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

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "jest.config.cts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

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

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "jest.config.cts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}