@teamvortexsoftware/vortex-fastify-5-sdk 0.0.1

package/dist/config.js

@@ -0,0 +1,168 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureVortex = configureVortex;
+exports.configureVortexAsync = configureVortexAsync;
+exports.configureVortexLazy = configureVortexLazy;
+exports.getVortexConfig = getVortexConfig;
+exports.authenticateRequest = authenticateRequest;
+exports.createAllowAllAccessControl = createAllowAllAccessControl;
+// Store configuration template (immutable after first set)
+var configTemplate = null;
+var isConfigLocked = false;
+var configPromise = null;
+var lazyConfigFactory = null;
+function configureVortex(config) {
+    if (isConfigLocked && configTemplate) {
+        throw new Error('Vortex configuration is already locked. Configuration can only be set once for security reasons.');
+    }
+    // Validate required config
+    if (!config.apiKey && !process.env.VORTEX_API_KEY) {
+        throw new Error('API key is required in config or VORTEX_API_KEY environment variable');
+    }
+    configTemplate = __assign({}, config);
+    isConfigLocked = true;
+}
+function configureVortexAsync(configPromiseOrConfig) {
+    if (configPromiseOrConfig instanceof Promise) {
+        configPromise = configPromiseOrConfig.then(function (config) {
+            configureVortex(config);
+        });
+    }
+    else {
+        configureVortex(configPromiseOrConfig);
+    }
+}
+function configureVortexLazy(configFactory) {
+    if (isConfigLocked && configTemplate) {
+        throw new Error('Vortex configuration is already locked. Configuration can only be set once for security reasons.');
+    }
+    lazyConfigFactory = configFactory;
+}
+function getVortexConfig() {
+    return __awaiter(this, void 0, void 0, function () {
+        var baseConfig;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // Initialize lazily if lazy factory is set and config hasn't been initialized
+                    if (lazyConfigFactory && !configTemplate && !configPromise) {
+                        // Lazy initializing Vortex configuration
+                        configPromise = lazyConfigFactory().then(function (config) {
+                            configureVortex(config);
+                        });
+                    }
+                    if (!(configPromise && !configTemplate)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, configPromise];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    baseConfig = {
+                        apiKey: (configTemplate === null || configTemplate === void 0 ? void 0 : configTemplate.apiKey) || process.env.VORTEX_API_KEY,
+                        apiBaseUrl: (configTemplate === null || configTemplate === void 0 ? void 0 : configTemplate.apiBaseUrl) || process.env.VORTEX_API_BASE_URL,
+                    };
+                    if (!baseConfig.apiKey) {
+                        throw new Error('Vortex not configured. Call configureVortex() or set VORTEX_API_KEY environment variable');
+                    }
+                    // Copy hooks from template if they exist
+                    if (configTemplate) {
+                        return [2 /*return*/, __assign(__assign({}, baseConfig), { authenticateUser: configTemplate.authenticateUser, canAccessInvitationsByTarget: configTemplate.canAccessInvitationsByTarget, canAccessInvitation: configTemplate.canAccessInvitation, canDeleteInvitation: configTemplate.canDeleteInvitation, canAcceptInvitations: configTemplate.canAcceptInvitations, canAccessInvitationsByGroup: configTemplate.canAccessInvitationsByGroup, canDeleteInvitationsByGroup: configTemplate.canDeleteInvitationsByGroup, canReinvite: configTemplate.canReinvite })];
+                    }
+                    return [2 /*return*/, baseConfig];
+            }
+        });
+    });
+}
+// Helper function to authenticate user for any request
+function authenticateRequest(request, reply) {
+    return __awaiter(this, void 0, void 0, function () {
+        var config, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getVortexConfig()];
+                case 1:
+                    config = _a.sent();
+                    if (!config.authenticateUser) {
+                        return [2 /*return*/, null];
+                    }
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, config.authenticateUser(request, reply)];
+                case 3: return [2 /*return*/, _a.sent()];
+                case 4:
+                    error_1 = _a.sent();
+                    // Log error but don't expose details
+                    console.error('Authentication error:', error_1);
+                    return [2 /*return*/, null];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Creates a set of access control hooks that allow all operations.
+ * Useful for demos, development, or when you want to handle authorization elsewhere.
+ */
+function createAllowAllAccessControl() {
+    var _this = this;
+    var allowAll = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, true];
+    }); }); };
+    return {
+        canAccessInvitationsByTarget: allowAll,
+        canAccessInvitation: allowAll,
+        canDeleteInvitation: allowAll,
+        canAcceptInvitations: allowAll,
+        canAccessInvitationsByGroup: allowAll,
+        canDeleteInvitationsByGroup: allowAll,
+        canReinvite: allowAll,
+    };
+}

package/dist/handlers/invitations.d.ts

@@ -0,0 +1,9 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+export declare function handleGetInvitationsByTarget(request: FastifyRequest, reply: FastifyReply): Promise<never>;
+export declare function handleGetInvitation(request: FastifyRequest, reply: FastifyReply): Promise<never>;
+export declare function handleRevokeInvitation(request: FastifyRequest, reply: FastifyReply): Promise<never>;
+export declare function handleAcceptInvitations(request: FastifyRequest, reply: FastifyReply): Promise<never>;
+export declare function handleGetInvitationsByGroup(request: FastifyRequest, reply: FastifyReply): Promise<never>;
+export declare function handleDeleteInvitationsByGroup(request: FastifyRequest, reply: FastifyReply): Promise<never>;
+export declare function handleReinvite(request: FastifyRequest, reply: FastifyReply): Promise<never>;
+//# sourceMappingURL=invitations.d.ts.map

package/dist/handlers/invitations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invitations.d.ts","sourceRoot":"","sources":["../../src/handlers/invitations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAKvD,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,kBAuC9F;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,kBAiCrF;AAED,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,kBA+BxF;AAED,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,kBAyDzF;AAED,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,kBAqC7F;AAED,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,kBAqChG;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,kBA+BhF"}

package/dist/handlers/invitations.js

@@ -0,0 +1,423 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetInvitationsByTarget = handleGetInvitationsByTarget;
+exports.handleGetInvitation = handleGetInvitation;
+exports.handleRevokeInvitation = handleRevokeInvitation;
+exports.handleAcceptInvitations = handleAcceptInvitations;
+exports.handleGetInvitationsByGroup = handleGetInvitationsByGroup;
+exports.handleDeleteInvitationsByGroup = handleDeleteInvitationsByGroup;
+exports.handleReinvite = handleReinvite;
+var vortex_node_22_sdk_1 = require("@teamvortexsoftware/vortex-node-22-sdk");
+var config_1 = require("../config");
+var utils_1 = require("../utils");
+function handleGetInvitationsByTarget(request, reply) {
+    return __awaiter(this, void 0, void 0, function () {
+        var config, user, hasAccess, targetType, targetValue, vortex, invitations, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    if (request.method !== 'GET') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Method not allowed', 405)];
+                    }
+                    return [4 /*yield*/, (0, config_1.getVortexConfig)()];
+                case 1:
+                    config = _a.sent();
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request, reply)];
+                case 2:
+                    user = _a.sent();
+                    if (!config.canAccessInvitationsByTarget) return [3 /*break*/, 4];
+                    return [4 /*yield*/, config.canAccessInvitationsByTarget(request, reply, user)];
+                case 3:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied', 403)];
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    if (!user) {
+                        // If no access control hook is configured, require authentication
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 5;
+                case 5:
+                    targetType = (0, utils_1.sanitizeInput)((0, utils_1.getQueryParam)(request, 'targetType'));
+                    targetValue = (0, utils_1.sanitizeInput)((0, utils_1.getQueryParam)(request, 'targetValue'));
+                    if (!targetType || !targetValue) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'targetType and targetValue query parameters are required', 400)];
+                    }
+                    if (!['email', 'username', 'phoneNumber'].includes(targetType)) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'targetType must be email, username, or phoneNumber', 400)];
+                    }
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.getInvitationsByTarget(targetType, targetValue)];
+                case 6:
+                    invitations = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(reply, { invitations: invitations })];
+                case 7:
+                    error_1 = _a.sent();
+                    console.error('Error in handleGetInvitationsByTarget:', error_1);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'An error occurred while processing your request', 500)];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleGetInvitation(request, reply) {
+    return __awaiter(this, void 0, void 0, function () {
+        var invitationId, sanitizedId, config, user, hasAccess, vortex, invitation, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    if (request.method !== 'GET') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Method not allowed', 405)];
+                    }
+                    invitationId = (0, utils_1.getRouteParam)(request, 'invitationId');
+                    sanitizedId = (0, utils_1.sanitizeInput)(invitationId);
+                    if (!sanitizedId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Invalid invitation ID', 400)];
+                    }
+                    return [4 /*yield*/, (0, config_1.getVortexConfig)()];
+                case 1:
+                    config = _a.sent();
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request, reply)];
+                case 2:
+                    user = _a.sent();
+                    if (!config.canAccessInvitation) return [3 /*break*/, 4];
+                    return [4 /*yield*/, config.canAccessInvitation(request, reply, user, { invitationId: sanitizedId })];
+                case 3:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied', 403)];
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 5;
+                case 5:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.getInvitation(sanitizedId)];
+                case 6:
+                    invitation = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(reply, invitation)];
+                case 7:
+                    error_2 = _a.sent();
+                    console.error('Error in handleGetInvitation:', error_2);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'An error occurred while processing your request', 500)];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleRevokeInvitation(request, reply) {
+    return __awaiter(this, void 0, void 0, function () {
+        var invitationId, sanitizedId, config, user, hasAccess, vortex, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    if (request.method !== 'DELETE') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Method not allowed', 405)];
+                    }
+                    invitationId = (0, utils_1.getRouteParam)(request, 'invitationId');
+                    sanitizedId = (0, utils_1.sanitizeInput)(invitationId);
+                    if (!sanitizedId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Invalid invitation ID', 400)];
+                    }
+                    return [4 /*yield*/, (0, config_1.getVortexConfig)()];
+                case 1:
+                    config = _a.sent();
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request, reply)];
+                case 2:
+                    user = _a.sent();
+                    if (!config.canDeleteInvitation) return [3 /*break*/, 4];
+                    return [4 /*yield*/, config.canDeleteInvitation(request, reply, user, { invitationId: sanitizedId })];
+                case 3:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied', 403)];
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 5;
+                case 5:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.revokeInvitation(sanitizedId)];
+                case 6:
+                    _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(reply, { success: true })];
+                case 7:
+                    error_3 = _a.sent();
+                    console.error('Error in handleRevokeInvitation:', error_3);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'An error occurred while processing your request', 500)];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleAcceptInvitations(request, reply) {
+    return __awaiter(this, void 0, void 0, function () {
+        var body, invitationIds, target, sanitizedIds, targetObj, validatedTarget, config, user, hasAccess, vortex, result, error_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 8, , 9]);
+                    if (request.method !== 'POST') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Method not allowed', 405)];
+                    }
+                    return [4 /*yield*/, (0, utils_1.parseRequestBody)(request)];
+                case 1:
+                    body = _a.sent();
+                    (0, utils_1.validateRequiredFields)(body, ['invitationIds', 'target']);
+                    invitationIds = body.invitationIds, target = body.target;
+                    if (!Array.isArray(invitationIds) || invitationIds.length === 0) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'invitationIds must be a non-empty array', 400)];
+                    }
+                    sanitizedIds = invitationIds.map(function (id) { return (0, utils_1.sanitizeInput)(id); }).filter(function (id) { return Boolean(id); });
+                    if (sanitizedIds.length !== invitationIds.length) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Invalid invitation IDs provided', 400)];
+                    }
+                    targetObj = target;
+                    if (!targetObj.type || !targetObj.value) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'target must have type and value properties', 400)];
+                    }
+                    if (!['email', 'username', 'phoneNumber'].includes(targetObj.type)) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'target.type must be email, username, or phoneNumber', 400)];
+                    }
+                    validatedTarget = { type: targetObj.type, value: targetObj.value };
+                    return [4 /*yield*/, (0, config_1.getVortexConfig)()];
+                case 2:
+                    config = _a.sent();
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request, reply)];
+                case 3:
+                    user = _a.sent();
+                    if (!config.canAcceptInvitations) return [3 /*break*/, 5];
+                    return [4 /*yield*/, config.canAcceptInvitations(request, reply, user, { invitationIds: sanitizedIds, target: validatedTarget })];
+                case 4:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied', 403)];
+                    }
+                    return [3 /*break*/, 6];
+                case 5:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 6;
+                case 6:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.acceptInvitations(sanitizedIds, {
+                            type: validatedTarget.type,
+                            value: (0, utils_1.sanitizeInput)(validatedTarget.value) || validatedTarget.value
+                        })];
+                case 7:
+                    result = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(reply, result)];
+                case 8:
+                    error_4 = _a.sent();
+                    console.error('Error in handleAcceptInvitations:', error_4);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'An error occurred while processing your request', 500)];
+                case 9: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleGetInvitationsByGroup(request, reply) {
+    return __awaiter(this, void 0, void 0, function () {
+        var groupType, groupId, sanitizedGroupType, sanitizedGroupId, config, user, hasAccess, vortex, invitations, error_5;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    if (request.method !== 'GET') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Method not allowed', 405)];
+                    }
+                    groupType = (0, utils_1.getRouteParam)(request, 'groupType');
+                    groupId = (0, utils_1.getRouteParam)(request, 'groupId');
+                    sanitizedGroupType = (0, utils_1.sanitizeInput)(groupType);
+                    sanitizedGroupId = (0, utils_1.sanitizeInput)(groupId);
+                    if (!sanitizedGroupType || !sanitizedGroupId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Invalid group parameters', 400)];
+                    }
+                    return [4 /*yield*/, (0, config_1.getVortexConfig)()];
+                case 1:
+                    config = _a.sent();
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request, reply)];
+                case 2:
+                    user = _a.sent();
+                    if (!config.canAccessInvitationsByGroup) return [3 /*break*/, 4];
+                    return [4 /*yield*/, config.canAccessInvitationsByGroup(request, reply, user, {
+                            groupType: sanitizedGroupType,
+                            groupId: sanitizedGroupId
+                        })];
+                case 3:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied', 403)];
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 5;
+                case 5:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.getInvitationsByGroup(sanitizedGroupType, sanitizedGroupId)];
+                case 6:
+                    invitations = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(reply, { invitations: invitations })];
+                case 7:
+                    error_5 = _a.sent();
+                    console.error('Error in handleGetInvitationsByGroup:', error_5);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'An error occurred while processing your request', 500)];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleDeleteInvitationsByGroup(request, reply) {
+    return __awaiter(this, void 0, void 0, function () {
+        var groupType, groupId, sanitizedGroupType, sanitizedGroupId, config, user, hasAccess, vortex, error_6;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    if (request.method !== 'DELETE') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Method not allowed', 405)];
+                    }
+                    groupType = (0, utils_1.getRouteParam)(request, 'groupType');
+                    groupId = (0, utils_1.getRouteParam)(request, 'groupId');
+                    sanitizedGroupType = (0, utils_1.sanitizeInput)(groupType);
+                    sanitizedGroupId = (0, utils_1.sanitizeInput)(groupId);
+                    if (!sanitizedGroupType || !sanitizedGroupId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Invalid group parameters', 400)];
+                    }
+                    return [4 /*yield*/, (0, config_1.getVortexConfig)()];
+                case 1:
+                    config = _a.sent();
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request, reply)];
+                case 2:
+                    user = _a.sent();
+                    if (!config.canDeleteInvitationsByGroup) return [3 /*break*/, 4];
+                    return [4 /*yield*/, config.canDeleteInvitationsByGroup(request, reply, user, {
+                            groupType: sanitizedGroupType,
+                            groupId: sanitizedGroupId
+                        })];
+                case 3:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied', 403)];
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 5;
+                case 5:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.deleteInvitationsByGroup(sanitizedGroupType, sanitizedGroupId)];
+                case 6:
+                    _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(reply, { success: true })];
+                case 7:
+                    error_6 = _a.sent();
+                    console.error('Error in handleDeleteInvitationsByGroup:', error_6);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'An error occurred while processing your request', 500)];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleReinvite(request, reply) {
+    return __awaiter(this, void 0, void 0, function () {
+        var invitationId, sanitizedId, config, user, hasAccess, vortex, invitation, error_7;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    if (request.method !== 'POST') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Method not allowed', 405)];
+                    }
+                    invitationId = (0, utils_1.getRouteParam)(request, 'invitationId');
+                    sanitizedId = (0, utils_1.sanitizeInput)(invitationId);
+                    if (!sanitizedId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Invalid invitation ID', 400)];
+                    }
+                    return [4 /*yield*/, (0, config_1.getVortexConfig)()];
+                case 1:
+                    config = _a.sent();
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request, reply)];
+                case 2:
+                    user = _a.sent();
+                    if (!config.canReinvite) return [3 /*break*/, 4];
+                    return [4 /*yield*/, config.canReinvite(request, reply, user, { invitationId: sanitizedId })];
+                case 3:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied', 403)];
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 5;
+                case 5:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.reinvite(sanitizedId)];
+                case 6:
+                    invitation = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(reply, invitation)];
+                case 7:
+                    error_7 = _a.sent();
+                    console.error('Error in handleReinvite:', error_7);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)(reply, 'An error occurred while processing your request', 500)];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}

package/dist/handlers/jwt.d.ts

@@ -0,0 +1,3 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+export declare function handleJwtGeneration(request: FastifyRequest, reply: FastifyReply): Promise<never>;
+//# sourceMappingURL=jwt.d.ts.map

package/dist/handlers/jwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../src/handlers/jwt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAKvD,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,kBAgCrF"}