Implement Factory Method task

Task/3-file-storage.d.ts

@@ -0,0 +1,25 @@
+export interface Query {
+  [key: string]: any;
+}
+
+export interface Record {
+  [key: string]: any;
+}
+
+export abstract class Database {
+  abstract select(query: Query): AsyncIterable<Record>;
+}
+
+export abstract class Cursor {
+  current: number;
+  [Symbol.asyncIterator](): AsyncIterator<Record>;
+}
+
+export class FileLineCursor extends Cursor {
+  constructor(fileStorage: FileStorage, query: Query);
+}
+
+export class FileStorage extends Database {
+  constructor(fileName: string);
+  select(query: Query): FileLineCursor;
+}

Task/3-file-storage.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const fs = require('node:fs');
+const readline = require('node:readline');
+
+class Database {
+  constructor() {
+    const proto = Object.getPrototypeOf(this);
+    if (proto.constructor === Database) {
+      throw new Error('Abstract class should not be instanciated');
+    }
+  }
+
+  select() {
+    throw new Error('Method is not implemented');
+  }
+}
+
+class Cursor {
+  constructor() {
+    const proto = Object.getPrototypeOf(this);
+    if (proto.constructor === Cursor) {
+      throw new Error('Abstract class should not be instanciated');
+    }
+    this.current = 0;
+  }
+
+  [Symbol.asyncIterator]() {
+    throw new Error('Method is not implemented');
+  }
+}
+
+class FileLineCursor extends Cursor {
+  constructor(fileStorage, query) {
+    super();
+    this.query = query;
+    this.lines = readline
+      .createInterface({
+        input: fileStorage.fileStream,
+        crlfDelay: Infinity,
+      })
+      [Symbol.asyncIterator]();
+  }
+
+  [Symbol.asyncIterator]() {
+    const cursor = this;
+    return {
+      async next() {
+        do {
+          const { value, done } = await cursor.lines.next();
+          if (done) return { done: true };
+          cursor.current++;
+          const data = JSON.parse(value);
+          let condition = true;
+          const { query } = cursor;
+          for (const field in query) {
+            condition = condition && data[field] === query[field];
+          }
+          if (condition) return { value: data, done: false };
+        } while (true);
+      },
+    };
+  }
+}
+
+class FileStorage extends Database {
+  constructor(fileName) {
+    super();
+    this.fileName = fileName;
+    this.fileStream = fs.createReadStream(fileName);
+  }
+
+  select(query) {
+    return new FileLineCursor(this, query);
+  }
+}
+
+module.exports = { FileStorage, FileLineCursor, Cursor, Database };

Task/__tests__/3-file-storage.integration.test.js

@@ -0,0 +1,47 @@
+const fs = require('node:fs/promises');
+const { FileStorage } = require('../3-file-storage');
+
+describe('FileStorage Integration Tests', () => {
+  const testFile = './storage.dat';
+
+  beforeAll(async () => {
+    const data = [
+      '{ "city": "Kiev", "name": "Glushkov" }',
+      '{ "city": "Roma", "name": "Marcus Aurelius" }',
+      '{ "city": "Shaoshan", "name": "Mao Zedong" }',
+      '{ "city": "Roma", "name": "Lucius Verus" }',
+    ].join('\n');
+
+    await fs.writeFile(testFile, data);
+  });
+
+  afterAll(async () => {
+    await fs.unlink(testFile);
+  });
+
+  it('should correctly filter records by city', async () => {
+    const db = new FileStorage(testFile);
+    const cursor = db.select({ city: 'Roma' });
+
+    const results = [];
+    for await (const record of cursor) {
+      results.push(record.name);
+    }
+
+    expect(results).toContain('Marcus Aurelius');
+    expect(results).toContain('Lucius Verus');
+    expect(results.length).toBe(2);
+  });
+
+  it('should return no records for unmatched query', async () => {
+    const db = new FileStorage(testFile);
+    const cursor = db.select({ city: 'Paris' });
+
+    const results = [];
+    for await (const record of cursor) {
+      results.push(record.name);
+    }
+
+    expect(results.length).toBe(0);
+  });
+});

Task/__tests__/3-file-storage.unit.test.js

@@ -0,0 +1,34 @@
+const { FileStorage } = require('../3-file-storage');
+const fs = require('node:fs');
+const readline = require('node:readline');
+
+jest.mock('node:fs');
+jest.mock('node:readline');
+
+describe('FileStorage Unit Tests', () => {
+  const fakeStream = {};
+  let storage;
+
+  beforeEach(() => {
+    fs.createReadStream.mockReturnValue(fakeStream);
+
+    const asyncIteratorMock = {
+      [Symbol.asyncIterator]: () => ({
+        next: jest.fn().mockResolvedValue({ done: true }),
+      }),
+    };
+
+    readline.createInterface.mockReturnValue(asyncIteratorMock);
+    storage = new FileStorage('fakefile.dat');
+  });
+
+  it('should initialize FileStorage with file stream', () => {
+    expect(fs.createReadStream).toHaveBeenCalledWith('fakefile.dat');
+    expect(storage.fileStream).toBe(fakeStream);
+  });
+
+  it('should return FileLineCursor from select', () => {
+    const cursor = storage.select({ city: 'Roma' });
+    expect(cursor.query).toEqual({ city: 'Roma' });
+  });
+});

Task/jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  testEnvironment: 'node'
+};