@eleven-am/pondsocket-nest 0.0.2

package/decorators/onLeave.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnLeave = void 0;
+const leave_1 = require("../managers/leave");
+const action_1 = require("../performers/action");
+function OnLeave() {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        const { set } = (0, leave_1.manageLeave)(target);
+        set('', (instance, moduleRef, leaveEvent) => __awaiter(this, void 0, void 0, function* () {
+            yield (0, action_1.performAction)(instance, moduleRef, originalMethod, propertyKey, leaveEvent);
+        }));
+    };
+}
+exports.OnLeave = OnLeave;

package/decorators/pondGuards.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondGuards = void 0;
+const guards_1 = require("../managers/guards");
+function PondGuards(...guards) {
+    return (target, propertyKey) => {
+        const { set } = (0, guards_1.manageGuards)(target, propertyKey);
+        set(guards);
+    };
+}
+exports.PondGuards = PondGuards;

package/helpers/createParamDecorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParamDecorator = void 0;
+const parametres_1 = require("../managers/parametres");
+function createParamDecorator(callback) {
+    return (data) => (target, propertyKey, index) => {
+        const { set } = (0, parametres_1.manageParameters)(target, propertyKey);
+        set(index, (context) => callback(data, context));
+    };
+}
+exports.createParamDecorator = createParamDecorator;

package/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./modules/pondSocket"), exports);

package/managers/channel.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageChannel = void 0;
+const class_1 = require("./class");
+const constants_1 = require("../constants");
+function manageChannel(target) {
+    return (0, class_1.manageClass)(constants_1.channelKey, target);
+}
+exports.manageChannel = manageChannel;

package/managers/channelInstance.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageChannelInstance = void 0;
+const property_1 = require("./property");
+const constants_1 = require("../constants");
+function manageChannelInstance(target) {
+    return (0, property_1.manageProperty)(constants_1.channelInstanceKey, target);
+}
+exports.manageChannelInstance = manageChannelInstance;

package/managers/class.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageClass = void 0;
+require("reflect-metadata");
+function manageClass(key, target) {
+    return {
+        get() {
+            var _a;
+            return ((_a = Reflect.getMetadata(key, target)) !== null && _a !== void 0 ? _a : null);
+        },
+        set(value) {
+            Reflect.defineMetadata(key, value, target);
+        },
+    };
+}
+exports.manageClass = manageClass;

package/managers/connection.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageConnection = void 0;
+const handlers_1 = require("./handlers");
+const constants_1 = require("../constants");
+function manageConnection(target) {
+    return (0, handlers_1.manageHandlers)(constants_1.onConnectionHandlerKey, target);
+}
+exports.manageConnection = manageConnection;

package/managers/endpoint.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageEndpoint = void 0;
+const class_1 = require("./class");
+const constants_1 = require("../constants");
+function manageEndpoint(target) {
+    return (0, class_1.manageClass)(constants_1.endpointKey, target);
+}
+exports.manageEndpoint = manageEndpoint;

package/managers/endpointInstance.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageEndpointInstance = void 0;
+const property_1 = require("./property");
+const constants_1 = require("../constants");
+function manageEndpointInstance(target) {
+    return (0, property_1.manageProperty)(constants_1.endpointInstanceKey, target);
+}
+exports.manageEndpointInstance = manageEndpointInstance;

package/managers/event.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageEvent = void 0;
+const handlers_1 = require("./handlers");
+const constants_1 = require("../constants");
+function manageEvent(target) {
+    return (0, handlers_1.manageHandlers)(constants_1.onEventHandlerKey, target);
+}
+exports.manageEvent = manageEvent;

package/managers/guards.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageGuards = void 0;
+const class_1 = require("./class");
+const method_1 = require("./method");
+const constants_1 = require("../constants");
+function manageGuards(target, propertyKey) {
+    let getter;
+    let setter;
+    if (propertyKey) {
+        const { get, set } = (0, method_1.manageMethod)(constants_1.pondGuardsKey, target, propertyKey);
+        getter = get;
+        setter = set;
+    }
+    else {
+        const { get, set } = (0, class_1.manageClass)(constants_1.pondGuardsKey, target);
+        getter = get;
+        setter = set;
+    }
+    return {
+        get: () => { var _a; return (_a = getter()) !== null && _a !== void 0 ? _a : []; },
+        set: (value) => {
+            var _a;
+            const current = (_a = getter()) !== null && _a !== void 0 ? _a : [];
+            setter([...value, ...current]);
+        },
+    };
+}
+exports.manageGuards = manageGuards;

package/managers/handlers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageHandlers = void 0;
+const class_1 = require("./class");
+function manageHandlers(key, target) {
+    const { get, set } = (0, class_1.manageClass)(key, target);
+    return {
+        get() {
+            return get() || [];
+        },
+        set(path, value) {
+            const handlers = get() || [];
+            set([
+                ...handlers,
+                {
+                    path,
+                    value,
+                },
+            ]);
+        },
+    };
+}
+exports.manageHandlers = manageHandlers;

package/managers/join.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageJoin = void 0;
+const handlers_1 = require("./handlers");
+const constants_1 = require("../constants");
+function manageJoin(target) {
+    return (0, handlers_1.manageHandlers)(constants_1.onJoinHandlerKey, target);
+}
+exports.manageJoin = manageJoin;

package/managers/leave.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageLeave = void 0;
+const handlers_1 = require("./handlers");
+const constants_1 = require("../constants");
+function manageLeave(target) {
+    return (0, handlers_1.manageHandlers)(constants_1.onLeaveHandlerKey, target);
+}
+exports.manageLeave = manageLeave;

package/managers/method.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageMethod = void 0;
+require("reflect-metadata");
+function manageMethod(key, target, propertyKey) {
+    return {
+        get() {
+            var _a;
+            return ((_a = Reflect.getMetadata(key, target, propertyKey)) !== null && _a !== void 0 ? _a : null);
+        },
+        set(value) {
+            Reflect.defineMetadata(key, value, target, propertyKey);
+        },
+    };
+}
+exports.manageMethod = manageMethod;

package/managers/parametres.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageParameters = void 0;
+require("reflect-metadata");
+const method_1 = require("./method");
+const constants_1 = require("../constants");
+function manageParameters(target, propertyKey) {
+    const { get, set } = (0, method_1.manageMethod)(constants_1.parametersKey, target, propertyKey);
+    return {
+        get() {
+            return get() || [];
+        },
+        set(index, callback) {
+            const handlers = get() || [];
+            set([
+                ...handlers,
+                {
+                    index,
+                    callback,
+                },
+            ]);
+        },
+    };
+}
+exports.manageParameters = manageParameters;

package/managers/property.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageProperty = void 0;
+function manageProperty(key, target) {
+    function build(propertyKey, callback) {
+        Object.defineProperty(target, propertyKey, {
+            get() {
+                const value = Reflect.getMetadata(key, this);
+                if (callback) {
+                    return callback(value);
+                }
+                return value;
+            },
+            set() {
+                throw new Error(`${propertyKey} is readonly`);
+            },
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    function set(value) {
+        Reflect.defineMetadata(key, value, target);
+    }
+    return {
+        build,
+        set,
+    };
+}
+exports.manageProperty = manageProperty;

package/modules/pondSocket.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondSocketModule = void 0;
+// eslint-disable-next-line import/no-unresolved
+const core_1 = require("@nestjs/core");
+// eslint-disable-next-line import/no-unresolved
+const modules_container_1 = require("@nestjs/core/injector/modules-container");
+const discovery_1 = require("../services/discovery");
+const pondSocket_1 = require("../services/pondSocket");
+class PondSocketModule {
+    static forRoot({ guards = [], providers = [], imports = [], exports = [], isGlobal = false, appModuleName = 'AppModule', }) {
+        const discoveryServiceProvider = {
+            provide: discovery_1.DiscoveryService,
+            useFactory: (moduleRef) => new discovery_1.DiscoveryService(moduleRef, appModuleName),
+            inject: [modules_container_1.ModulesContainer, core_1.HttpAdapterHost],
+        };
+        const pondSocketProvider = {
+            provide: pondSocket_1.PondSocketService,
+            useFactory: (moduleRef, adapterHost, discovery) => new pondSocket_1.PondSocketService(moduleRef, discovery, adapterHost, guards),
+            inject: [core_1.ModuleRef, core_1.HttpAdapterHost, discovery_1.DiscoveryService],
+        };
+        return {
+            imports,
+            exports,
+            global: isGlobal,
+            module: PondSocketModule,
+            providers: [
+                discoveryServiceProvider,
+                pondSocketProvider,
+                ...providers,
+                ...guards,
+            ],
+        };
+    }
+}
+exports.PondSocketModule = PondSocketModule;

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@eleven-am/pondsocket-nest",
+  "version": "0.0.2",
+  "description": "PondSocket is a fast simple socket server",
+  "keywords": [
+    "socket",
+    "server",
+    "ws",
+    "websocket",
+    "pubsub",
+    "presence",
+    "realtime",
+    "realtime server"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Roy OSSAI",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "license": "GPL-3.0",
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "lint": "eslint --ext .ts src",
+    "lint:fix": "eslint --fix --ext .ts src",
+    "copy": "cp package.json dist && cp README.md dist && cp LICENSE dist && cp src/context.d.ts dist",
+    "push": "npm version patch && npm run copy && cd dist && npm publish && cd ..",
+    "pipeline": "npm run lint && npm run build && npm run push"
+  },
+  "dependencies": {
+    "@eleven-am/pondsocket": "^0.1.127"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^10.3.0",
+    "@nestjs/core": "^10.3.0",
+    "@types/jest": "^29.5.11",
+    "@typescript-eslint/eslint-plugin": "^6.18.0",
+    "eslint-plugin-file-progress": "^1.3.0",
+    "eslint-plugin-import": "^2.29.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.1.1",
+    "ts-jest": "^29.1.1",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.test\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/performers/action.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performAction = void 0;
+const guards_1 = require("./guards");
+const response_1 = require("./response");
+const context_1 = require("../context/context");
+const parametres_1 = require("../managers/parametres");
+function retrieveParameters(context) {
+    var _a;
+    const gottenValues = (_a = (0, parametres_1.manageParameters)(context.getClass(), context.getHandler()).get()) !== null && _a !== void 0 ? _a : [];
+    const values = gottenValues
+        .map(({ callback, index }) => ({
+        value: callback(context),
+        index,
+    }));
+    return values
+        .sort((a, b) => a.index - b.index)
+        .map(({ value }) => value);
+}
+function performAction(instance, moduleRef, originalMethod, propertyKey, leaveEvent, request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const req = {};
+        const res = {};
+        if (request && response) {
+            if ('joinParams' in request && 'broadcast' in response && !('sendOnly' in response)) {
+                req.joinRequest = request;
+                res.joinResponse = response;
+            }
+            else if ('channel' in request && 'sendOnly' in response) {
+                req.eventRequest = request;
+                res.eventResponse = response;
+            }
+            else if ('headers' in request) {
+                req.connection = request;
+                res.connection = response;
+            }
+        }
+        else if (leaveEvent) {
+            req.leveeEvent = leaveEvent;
+        }
+        const context = new context_1.Context(req, res, instance, propertyKey);
+        const channel = context.channel;
+        const canProceed = yield (0, guards_1.performGuards)(moduleRef, context);
+        if (canProceed) {
+            const data = yield originalMethod.apply(instance, retrieveParameters(context));
+            (0, response_1.performResponse)(data, channel, response);
+        }
+        else if (response) {
+            response.reject('Unauthorized', 401);
+        }
+    });
+}
+exports.performAction = performAction;

package/performers/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performErrors = void 0;
+// eslint-disable-next-line import/no-unresolved
+const common_1 = require("@nestjs/common");
+function performErrors(error, response) {
+    if (response.hasResponded) {
+        return response;
+    }
+    if (error instanceof common_1.HttpException) {
+        return response.reject(error.message, error.getStatus());
+    }
+    if (error instanceof Error) {
+        return response.reject(error.message, 500);
+    }
+}
+exports.performErrors = performErrors;

package/performers/guards.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performGuards = void 0;
+const guards_1 = require("../managers/guards");
+function retrieveGuard(moduleRef, Guard) {
+    try {
+        return moduleRef.get(Guard, { strict: false });
+    }
+    catch (e) {
+        console.warn(`Unable to resolve guard: ${Guard.name}, creating new instance, WARNING: this will not inject dependencies. To fix this, add the guard to the providers array of the PondSocketModule.`);
+        return new Guard();
+    }
+}
+function performGuards(moduleRef, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const classGuards = (0, guards_1.manageGuards)(context.getClass()).get();
+        const methodGuards = (0, guards_1.manageGuards)(context.getClass(), context.getHandler()).get();
+        const guards = []
+            .concat(classGuards, methodGuards)
+            .map((Guard) => retrieveGuard(moduleRef, Guard));
+        const promises = guards.map((guard) => guard.canActivate(context));
+        const results = yield Promise.all(promises);
+        return results.every((result) => result);
+    });
+}
+exports.performGuards = performGuards;

package/performers/response.js

@@ -0,0 +1,52 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performResponse = void 0;
+function isNotEmpty(value) {
+    return value !== null &&
+        value !== undefined &&
+        value !== '' &&
+        Object.keys(value).length !== 0;
+}
+function performResponse(data, channel, response) {
+    if (response && response.hasResponded || !isNotEmpty(data)) {
+        return;
+    }
+    const { event, presence, updatePresence, assigns, broadcast } = data, rest = __rest(data, ["event", "presence", "updatePresence", "assigns", "broadcast"]);
+    if (response) {
+        if (event && typeof event === 'string' && isNotEmpty(rest)) {
+            if ('sendOnly' in response) {
+                response.sendOnly(event, rest, assigns);
+            }
+            else {
+                response.send(event, rest, assigns);
+            }
+        }
+        else if (isNotEmpty(assigns)) {
+            response.accept(assigns);
+        }
+        if (broadcast && typeof broadcast === 'string' && isNotEmpty(rest) && 'broadcast' in response) {
+            response.broadcast(broadcast, rest);
+        }
+        if ('trackPresence' in response && presence) {
+            response.trackPresence(presence);
+        }
+        else if ('updatePresence' in response && updatePresence) {
+            response.updatePresence(updatePresence);
+        }
+    }
+    else if (channel && broadcast && typeof broadcast === 'string' && isNotEmpty(rest)) {
+        channel.broadcastMessage(broadcast, rest);
+    }
+}
+exports.performResponse = performResponse;