chore: add src/context

.github/workflows/ci.yml

@@ -54,6 +54,6 @@ jobs:
     - name: Build examples
       run: npm link && cd examples && npm i && npm link ydb-sdk && npm run build
     - name: Run tests
-      run: npm run test:all
+      run: npm run test:prod
       env:
         YDB_SSL_ROOT_CERTIFICATES_FILE: /tmp/ydb_certs/ca.pem

jest.config.coverage.js

@@ -1,4 +1,4 @@
-const config = require('./jest.config.development');
+const config = require('./jest.config.dev');
 
 /*
  * For a detailed explanation regarding each configuration property and type check, visit:

package.json

@@ -14,12 +14,10 @@
     "build/**"
   ],
   "scripts": {
-    "test:unit": "exit 0",
-    "test:integration:development": "cross-env TEST_ENVIRONMENT=dev jest --config jest.config.development.js",
-    "test:integration:production": "jest --config jest.config.production.js",
-    "test:all": "run-p test:unit test:integration:production",
+    "test:dev": "cross-env TEST_ENVIRONMENT=dev jest --config jest.config.dev.js",
+    "test:prod": "jest --config jest.config.prod.js",
     "test:coverage": "cross-env TEST_ENVIRONMENT=dev jest --config jest.config.coverage.js",
-    "test": "npm run test:unit",
+    "test": "npm run test:dev",
     "build": "tsc -p tsconfig-esm.json && tsc -p tsconfig-cjs.json",
     "clean": "rimraf build",
     "prepublish": "npm run clean && npm run build && node ./fixup.js"

src/__tests__/e2e/query-service/transactions.ts

@@ -21,7 +21,7 @@ describe('Query service transactions', () => {
 
     afterAll(async () => {
         discoveryService.destroy();
-        await session[symbols.sessionRelease]();
+        await session[symbols.sessionReleaseSymbol]();
         await session.delete();
     });
 

src/__tests__/unit/context-do.test.ts

@@ -0,0 +1,53 @@
+import {Context, setContextIdGenerator} from "../../context/Context";
+
+describe('Context.do', () => {
+    beforeEach(() => {
+        setContextIdGenerator(); // reset default
+    });
+
+    it('general', () => {
+        const ctx = Context.createNew().ctx;
+
+        function test(n: number) {
+            expect(Context.get()).toBeDefined();
+            expect(n).toBe(12);
+            return n;
+        }
+
+        const res = ctx.do(() => test(12));
+
+        expect(res).toBe(12);
+    });
+
+    it('async', async () => {
+        const ctx = Context.createNew().ctx;
+
+        async function test(n: number) {
+            expect(Context.get()).toBeDefined();
+            await new Promise((resolve) =>{
+                setTimeout(resolve, 0);
+            });
+            expect(() => Context.get()).toThrow(); // because it's after await
+            expect(n).toBe(12);
+            return n;
+        }
+
+        const res = await ctx.do(() => test(12));
+
+        expect(res).toBe(12);
+    });
+
+    it('no current context', async () => {
+        expect(() => Context.get())
+            .toThrow(`"ctx" was either not passed through Context.do() or was already taken through Context.get()`);
+    });
+
+    it('unprocessed current context', async () => {
+        const ctx = Context.createNew().ctx;
+
+        ctx.do(() => {
+            expect(() => ctx.do(() => {}))
+                .toThrow(`There is a "ctx" that was passed through "ctx.do()" and was not processed till next "ctx.do()": 0001`)
+        })
+    });
+});

src/__tests__/unit/context-ensure.test.ts

@@ -0,0 +1,78 @@
+import {Context} from "../../context/Context";
+import {EnsureContext} from "../../context/ensureContext";
+
+describe('ensureContext', () => {
+    it('positional args', () => {
+        class Test {
+            // @ts-ignore
+            noArgs(): void;
+            noArgs(ctx: Context): void;
+            @EnsureContext(true)
+            noArgs(ctx: Context): void {
+                expect(ctx instanceof Context).toBeTruthy();
+            }
+
+            // @ts-ignore
+            posArgs(n: number, s: string): void;
+            posArgs(ctx: Context, n: number, s: string): void;
+            @EnsureContext(true)
+            posArgs(ctx: Context, n: number, s: string) {
+                expect(ctx instanceof Context).toBeTruthy();
+                expect(n).toBe(12);
+                expect(s).toBe('test');
+            }
+
+            // @ts-ignore
+            static staticNoArgs(): void;
+            static staticNoArgs(ctx: Context): void;
+
+            @EnsureContext(true)
+            static staticNoArgs(ctx: Context) {
+                expect(ctx instanceof Context).toBeTruthy();
+            }
+        }
+
+        const test = new Test();
+
+        test.noArgs();
+        test.noArgs(Context.createNew().ctx);
+
+        test.posArgs(12, 'test');
+        test.posArgs(Context.createNew().ctx, 12, 'test');
+
+        Test.staticNoArgs();
+    });
+
+    it('named args', () => {
+        class Test {
+            // noArgs(): void;
+            // noArgs(opts: {
+            //     ctx?: Context,
+            // }): void;
+            @EnsureContext()
+            noArgs(opts?: {
+                ctx?: Context,
+            }): void {
+                const ctx = opts!.ctx!;
+                expect(ctx instanceof Context).toBeTruthy();
+            }
+
+            @EnsureContext(false) // should throw error cause fire arg is not obj
+            mismatchTypeOfArgs(n: number, s: string) {
+                expect(n).toBe(12);
+                expect(s).toBe('test');
+            }
+        }
+
+        const test = new Test();
+
+        test.noArgs();
+        test.noArgs({});
+        test.noArgs({
+            ctx: Context.createNew().ctx,
+        });
+
+        expect(() => test.mismatchTypeOfArgs(12, 'test')).rejects
+            .toThrow('An object with options or undefined is expected as the first argument');
+    });
+});