@ballistix.digital/identity-connector 0.0.0-local

package/dist/testing/service/userStore.contract.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userStoreContract = userStoreContract;
+const assert_1 = __importDefault(require("assert"));
+const crypto_1 = require("crypto");
+const identityConnectorExceptionType_enum_1 = require("../../common/domain/enum/identityConnectorExceptionType.enum");
+const identityConnectorException_1 = require("../../module/identity/domain/exception/identityConnectorException");
+function userStoreContract(fixture) {
+    const identityId = () => `contract-${(0, crypto_1.randomUUID)()}`;
+    const sample = () => ({ email: `contract-${(0, crypto_1.randomUUID)()}@example.com`, givenName: 'Contract', familyName: 'User' });
+    return [
+        {
+            name: 'creates one user for an identity, however often create runs for it',
+            run: async () => {
+                const { store, providers, userId } = await fixture();
+                const { email, givenName, familyName } = sample();
+                const identity = {
+                    provider: providers[0],
+                    id: identityId(),
+                    email,
+                    emailVerified: true,
+                    givenName,
+                    familyName,
+                    roles: [],
+                };
+                const [first, second] = await Promise.all([store.create(identity), store.create(identity)]);
+                if (first === null && second === null) {
+                    return;
+                }
+                assert_1.default.notStrictEqual(first, null);
+                assert_1.default.strictEqual(userId(second), userId(first));
+                assert_1.default.strictEqual(userId((await store.findByIdentityId(identity.id, identity.provider))), userId(first));
+            },
+        },
+        {
+            name: 'finds no user for an identity nobody is linked to',
+            run: async () => {
+                const { store, providers } = await fixture();
+                assert_1.default.strictEqual(await store.findByIdentityId(identityId(), providers[0]), null);
+            },
+        },
+        {
+            name: 'links a user without an identity, and finds the user by that identity afterwards',
+            run: async () => {
+                const { store, providers, createUser, userId } = await fixture();
+                const user = await createUser(sample());
+                const id = identityId();
+                assert_1.default.strictEqual(await store.link(user, id, providers[0]), true);
+                assert_1.default.strictEqual(userId((await store.findByIdentityId(id, providers[0]))), userId(user));
+            },
+        },
+        {
+            name: 'links a user to the identity it already has again',
+            run: async () => {
+                const { store, providers, createUser } = await fixture();
+                const user = await createUser(sample());
+                const id = identityId();
+                await store.link(user, id, providers[0]);
+                assert_1.default.strictEqual(await store.link(user, id, providers[0]), true);
+            },
+        },
+        {
+            name: 'refuses to link a user that already has another identity of the same provider',
+            run: async () => {
+                const { store, providers, createUser, userId } = await fixture();
+                const user = await createUser(sample());
+                const first = identityId();
+                const second = identityId();
+                await store.link(user, first, providers[0]);
+                assert_1.default.strictEqual(await store.link(user, second, providers[0]), false);
+                assert_1.default.strictEqual(userId((await store.findByIdentityId(first, providers[0]))), userId(user));
+                assert_1.default.strictEqual(await store.findByIdentityId(second, providers[0]), null);
+            },
+        },
+        {
+            name: 'refuses to link an identity another user has',
+            run: async () => {
+                const { store, providers, createUser, userId } = await fixture();
+                const owner = await createUser(sample());
+                const other = await createUser(sample());
+                const id = identityId();
+                assert_1.default.strictEqual(await store.link(owner, id, providers[0]), true);
+                assert_1.default.strictEqual(await store.link(other, id, providers[0]), false);
+                assert_1.default.strictEqual(userId((await store.findByIdentityId(id, providers[0]))), userId(owner));
+            },
+        },
+        {
+            name: 'links a copy of a user, loaded on its own, to the identity the user has',
+            run: async () => {
+                const { store, providers, createUser, userId } = await fixture();
+                const user = await createUser(sample());
+                const id = identityId();
+                assert_1.default.strictEqual(await store.link(user, id, providers[0]), true);
+                const copy = (await store.findByIdentityId(id, providers[0]));
+                assert_1.default.strictEqual(await store.link(copy, id, providers[0]), true);
+                assert_1.default.strictEqual(userId((await store.findByIdentityId(id, providers[0]))), userId(user));
+            },
+        },
+        {
+            name: 'links an identity to one user only when two users link it at once',
+            run: async () => {
+                const { store, providers, createUser, userId } = await fixture();
+                const first = await createUser(sample());
+                const second = await createUser(sample());
+                const id = identityId();
+                const linked = await Promise.all([store.link(first, id, providers[0]), store.link(second, id, providers[0])]);
+                assert_1.default.deepStrictEqual(linked.filter((wasLinked) => wasLinked), [true]);
+                const owner = linked[0] ? first : second;
+                assert_1.default.strictEqual(userId((await store.findByIdentityId(id, providers[0]))), userId(owner));
+            },
+        },
+        {
+            name: 'gives the provider a profile with the identity id once the user is linked',
+            run: async () => {
+                const { store, providers, createUser } = await fixture();
+                const values = sample();
+                const user = await createUser(values);
+                const id = identityId();
+                assert_1.default.deepStrictEqual(store.toProfile(user, providers[0]), { identityId: null, ...values });
+                await store.link(user, id, providers[0]);
+                const linked = (await store.findByIdentityId(id, providers[0]));
+                assert_1.default.deepStrictEqual(store.toProfile(linked, providers[0]), { identityId: id, ...values });
+            },
+        },
+        {
+            name: 'throws NO_EMAIL for the profile of a user without an email',
+            run: async () => {
+                const { store, providers, createUser, usersWithoutEmail = true } = await fixture();
+                if (!usersWithoutEmail) {
+                    return;
+                }
+                const user = await createUser({ ...sample(), email: null });
+                assert_1.default.throws(() => store.toProfile(user, providers[0]), (error) => (0, identityConnectorException_1.identityConnectorExceptionTypeOf)(error) === identityConnectorExceptionType_enum_1.IdentityConnectorExceptionTypeEnum.NO_EMAIL);
+            },
+        },
+        {
+            name: 'keeps the identities of two providers apart',
+            run: async () => {
+                const { store, providers, createUser, userId } = await fixture();
+                if (providers.length < 2) {
+                    return;
+                }
+                const [first, second] = providers;
+                const user = await createUser(sample());
+                const id = identityId();
+                await store.link(user, id, first);
+                assert_1.default.strictEqual(await store.findByIdentityId(id, second), null);
+                assert_1.default.strictEqual(await store.link(user, identityId(), second), true);
+                assert_1.default.strictEqual(userId((await store.findByIdentityId(id, first))), userId(user));
+            },
+        },
+    ];
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { IdentityConnectorExceptionTypeEnum } from '../common/domain/enum/identityConnectorExceptionType.enum';

package/dist/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityConnectorExceptionTypeEnum = void 0;
+var identityConnectorExceptionType_enum_1 = require("../common/domain/enum/identityConnectorExceptionType.enum");
+Object.defineProperty(exports, "IdentityConnectorExceptionTypeEnum", { enumerable: true, get: function () { return identityConnectorExceptionType_enum_1.IdentityConnectorExceptionTypeEnum; } });

package/package.json

@@ -0,0 +1,139 @@
+{
+	"name": "@ballistix.digital/identity-connector",
+	"version": "0.0.0-local",
+	"description": "NestJS module that signs a user in with an OIDC access token and provisions users at one or more identity providers, behind provider-agnostic contracts.",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/layeredprints/identity-connector.git"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"engines": {
+		"node": ">=24"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./zitadel": {
+			"types": "./dist/module/zitadel/index.d.ts",
+			"default": "./dist/module/zitadel/index.js"
+		},
+		"./entra": {
+			"types": "./dist/module/entra/index.d.ts",
+			"default": "./dist/module/entra/index.js"
+		},
+		"./testing": {
+			"types": "./dist/testing/index.d.ts",
+			"default": "./dist/testing/index.js"
+		},
+		"./types": {
+			"types": "./dist/types/index.d.ts",
+			"default": "./dist/types/index.js"
+		},
+		"./dist/*": {
+			"types": "./dist/*.d.ts",
+			"default": "./dist/*.js"
+		}
+	},
+	"typesVersions": {
+		"*": {
+			"zitadel": [
+				"dist/module/zitadel/index.d.ts"
+			],
+			"entra": [
+				"dist/module/entra/index.d.ts"
+			],
+			"testing": [
+				"dist/testing/index.d.ts"
+			],
+			"types": [
+				"dist/types/index.d.ts"
+			]
+		}
+	},
+	"files": [
+		"dist",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"build": "rm -rf dist && tsc -p tsconfig.build.json",
+		"lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+		"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+		"test": "jest --selectProjects unit",
+		"test:unit": "jest --selectProjects unit",
+		"test:packaging": "npm run build && jest --selectProjects packaging",
+		"test:watch": "jest --selectProjects unit --watch",
+		"test:coverage": "jest --selectProjects unit --coverage"
+	},
+	"peerDependencies": {
+		"@ballistix.digital/exception-mapper": ">=0.8.0 <1.0.0",
+		"@ballistix.digital/exception-types": ">=0.8.0 <1.0.0",
+		"@nestjs/common": "^11 || ^12",
+		"@nestjs/core": "^11 || ^12",
+		"class-transformer": "^0.5.1",
+		"class-validator": "^0.15.1",
+		"jose": "^6",
+		"reflect-metadata": "^0.2"
+	},
+	"peerDependenciesMeta": {
+		"@ballistix.digital/exception-mapper": {
+			"optional": true
+		},
+		"@ballistix.digital/exception-types": {
+			"optional": true
+		},
+		"@nestjs/common": {
+			"optional": true
+		},
+		"@nestjs/core": {
+			"optional": true
+		},
+		"class-transformer": {
+			"optional": true
+		},
+		"class-validator": {
+			"optional": true
+		},
+		"jose": {
+			"optional": true
+		},
+		"reflect-metadata": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@ballistix.digital/exception-mapper": "^0.8.0",
+		"@ballistix.digital/exception-types": "^0.8.0",
+		"@nestjs/common": "^11.1.6",
+		"@nestjs/core": "^11.1.6",
+		"@nestjs/swagger": "^11.0.6",
+		"@nestjs/testing": "^11.1.6",
+		"@types/jest": "^30.0.0",
+		"@types/jsonwebtoken": "^9.0.10",
+		"@types/node": "^24.19.2",
+		"@typescript-eslint/eslint-plugin": "^8.44.0",
+		"@typescript-eslint/parser": "^8.44.0",
+		"class-transformer": "^0.5.1",
+		"class-validator": "0.15.1",
+		"eslint": "^8.57.1",
+		"eslint-config-prettier": "^9.1.0",
+		"eslint-plugin-prettier": "^5.5.0",
+		"jest": "^30.0.0",
+		"jose": "^6.2.13",
+		"jsonwebtoken": "^9.0.3",
+		"lodash": "^4.17.21",
+		"luxon": "^3.7.2",
+		"prettier": "^3.6.0",
+		"reflect-metadata": "^0.2.2",
+		"rxjs": "^7.8.2",
+		"ts-jest": "^29.4.0",
+		"typeorm": "^1.1.0",
+		"typescript": "^5.9.0"
+	}
+}