@teamvortexsoftware/vortex-nextjs-15-sdk 0.0.1

package/dist/config.js

@@ -0,0 +1,107 @@
+"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.getVortexConfig = getVortexConfig;
+exports.authenticateRequest = authenticateRequest;
+// Store configuration template (immutable after first set)
+var configTemplate = null;
+var isConfigLocked = false;
+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 getVortexConfig(request) {
+    // Create a fresh config for each request
+    var 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 __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 baseConfig;
+}
+// Helper function to authenticate user for any request
+function authenticateRequest(request) {
+    return __awaiter(this, void 0, void 0, function () {
+        var config, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = getVortexConfig(request);
+                    if (!config.authenticateUser) {
+                        return [2 /*return*/, null];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, config.authenticateUser(request)];
+                case 2: return [2 /*return*/, _a.sent()];
+                case 3:
+                    error_1 = _a.sent();
+                    // Log error but don't expose details
+                    console.error('Authentication error:', error_1);
+                    return [2 /*return*/, null];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}

package/dist/examples.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Example Next.js API route setups for Vortex integration
+ *
+ * To use these examples in your Next.js app, create the corresponding
+ * files in your app/api directory with the following structure:
+ */
+export declare const jwtRouteExample = "\nimport { createVortexJwtRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const POST = createVortexJwtRoute();\n";
+export declare const invitationsRouteExample = "\nimport { createVortexInvitationsRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { GET } = createVortexInvitationsRoute();\n";
+export declare const invitationByIdRouteExample = "\nimport { createVortexInvitationRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { GET, DELETE } = createVortexInvitationRoute();\n";
+export declare const acceptInvitationsRouteExample = "\nimport { createVortexInvitationsAcceptRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { POST } = createVortexInvitationsAcceptRoute();\n";
+export declare const invitationsByGroupRouteExample = "\nimport { createVortexInvitationsByGroupRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { GET, DELETE } = createVortexInvitationsByGroupRoute();\n";
+export declare const reinviteRouteExample = "\nimport { createVortexReinviteRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { POST } = createVortexReinviteRoute();\n";
+export declare const configurationExample = "\n// In your app initialization (e.g., in a layout.tsx or _app.tsx equivalent):\nimport { configureVortex, type AuthenticatedUser } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\nimport { NextRequest } from 'next/server';\n\n// Example with custom authentication logic\nconfigureVortex({\n  apiKey: process.env.VORTEX_API_KEY!,\n  apiBaseUrl: process.env.VORTEX_API_BASE_URL, // optional\n  authenticateUser: async (request: NextRequest): Promise<AuthenticatedUser | null> => {\n    // Your authentication logic here - extract user from session, JWT, etc.\n    const sessionToken = request.headers.get('authorization')?.replace('Bearer ', '');\n\n    if (!sessionToken) {\n      return null;\n    }\n\n    // Example: decode your session token and get user info\n    const user = await validateSessionAndGetUser(sessionToken);\n\n    if (!user) {\n      return null;\n    }\n\n    return {\n      userId: user.id,\n      identifiers: [{ type: 'email', value: user.email }],\n      groups: user.organizations.map(org => ({\n        type: 'organization',\n        id: org.id,\n        name: org.name\n      })),\n      role: user.role\n    };\n  }\n});\n\n// Minimal setup with environment variables only (JWT endpoint will require authenticateUser hook):\nconfigureVortex({\n  apiKey: process.env.VORTEX_API_KEY!,\n});\n";
+/**
+ * Complete API Routes Summary:
+ *
+ * POST /api/vortex/jwt
+ * - Generate JWT token for authentication
+ *
+ * GET /api/vortex/invitations?targetType={email|username|phoneNumber}&targetValue={value}
+ * - Get invitations by target
+ *
+ * GET /api/vortex/invitations/[invitationId]
+ * - Get specific invitation
+ *
+ * DELETE /api/vortex/invitations/[invitationId]
+ * - Revoke/delete invitation
+ *
+ * POST /api/vortex/invitations/accept
+ * - Accept invitations
+ *
+ * GET /api/vortex/invitations/by-group/[groupType]/[groupId]
+ * - Get invitations by group
+ *
+ * DELETE /api/vortex/invitations/by-group/[groupType]/[groupId]
+ * - Delete invitations by group
+ *
+ * POST /api/vortex/invitations/[invitationId]/reinvite
+ * - Resend invitation
+ */ 
+//# sourceMappingURL=examples.d.ts.map

package/dist/examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples.d.ts","sourceRoot":"","sources":["../src/examples.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,eAAO,MAAM,eAAe,wIAI3B,CAAC;AAGF,eAAO,MAAM,uBAAuB,2JAInC,CAAC;AAGF,eAAO,MAAM,0BAA0B,iKAItC,CAAC;AAGF,eAAO,MAAM,6BAA6B,wKAIzC,CAAC;AAGF,eAAO,MAAM,8BAA8B,iLAI1C,CAAC;AAGF,eAAO,MAAM,oBAAoB,sJAIhC,CAAC;AAGF,eAAO,MAAM,oBAAoB,+yCAyChC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG"}

package/dist/examples.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Example Next.js API route setups for Vortex integration
+ *
+ * To use these examples in your Next.js app, create the corresponding
+ * files in your app/api directory with the following structure:
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurationExample = exports.reinviteRouteExample = exports.invitationsByGroupRouteExample = exports.acceptInvitationsRouteExample = exports.invitationByIdRouteExample = exports.invitationsRouteExample = exports.jwtRouteExample = void 0;
+// app/api/vortex/jwt/route.ts
+exports.jwtRouteExample = "\nimport { createVortexJwtRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const POST = createVortexJwtRoute();\n";
+// app/api/vortex/invitations/route.ts
+exports.invitationsRouteExample = "\nimport { createVortexInvitationsRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { GET } = createVortexInvitationsRoute();\n";
+// app/api/vortex/invitations/[invitationId]/route.ts
+exports.invitationByIdRouteExample = "\nimport { createVortexInvitationRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { GET, DELETE } = createVortexInvitationRoute();\n";
+// app/api/vortex/invitations/accept/route.ts
+exports.acceptInvitationsRouteExample = "\nimport { createVortexInvitationsAcceptRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { POST } = createVortexInvitationsAcceptRoute();\n";
+// app/api/vortex/invitations/by-group/[groupType]/[groupId]/route.ts
+exports.invitationsByGroupRouteExample = "\nimport { createVortexInvitationsByGroupRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { GET, DELETE } = createVortexInvitationsByGroupRoute();\n";
+// app/api/vortex/invitations/[invitationId]/reinvite/route.ts
+exports.reinviteRouteExample = "\nimport { createVortexReinviteRoute } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\n\nexport const { POST } = createVortexReinviteRoute();\n";
+// Configuration example
+exports.configurationExample = "\n// In your app initialization (e.g., in a layout.tsx or _app.tsx equivalent):\nimport { configureVortex, type AuthenticatedUser } from '@teamvortexsoftware/vortex-nextjs-15-sdk';\nimport { NextRequest } from 'next/server';\n\n// Example with custom authentication logic\nconfigureVortex({\n  apiKey: process.env.VORTEX_API_KEY!,\n  apiBaseUrl: process.env.VORTEX_API_BASE_URL, // optional\n  authenticateUser: async (request: NextRequest): Promise<AuthenticatedUser | null> => {\n    // Your authentication logic here - extract user from session, JWT, etc.\n    const sessionToken = request.headers.get('authorization')?.replace('Bearer ', '');\n\n    if (!sessionToken) {\n      return null;\n    }\n\n    // Example: decode your session token and get user info\n    const user = await validateSessionAndGetUser(sessionToken);\n\n    if (!user) {\n      return null;\n    }\n\n    return {\n      userId: user.id,\n      identifiers: [{ type: 'email', value: user.email }],\n      groups: user.organizations.map(org => ({\n        type: 'organization',\n        id: org.id,\n        name: org.name\n      })),\n      role: user.role\n    };\n  }\n});\n\n// Minimal setup with environment variables only (JWT endpoint will require authenticateUser hook):\nconfigureVortex({\n  apiKey: process.env.VORTEX_API_KEY!,\n});\n";
+/**
+ * Complete API Routes Summary:
+ *
+ * POST /api/vortex/jwt
+ * - Generate JWT token for authentication
+ *
+ * GET /api/vortex/invitations?targetType={email|username|phoneNumber}&targetValue={value}
+ * - Get invitations by target
+ *
+ * GET /api/vortex/invitations/[invitationId]
+ * - Get specific invitation
+ *
+ * DELETE /api/vortex/invitations/[invitationId]
+ * - Revoke/delete invitation
+ *
+ * POST /api/vortex/invitations/accept
+ * - Accept invitations
+ *
+ * GET /api/vortex/invitations/by-group/[groupType]/[groupId]
+ * - Get invitations by group
+ *
+ * DELETE /api/vortex/invitations/by-group/[groupType]/[groupId]
+ * - Delete invitations by group
+ *
+ * POST /api/vortex/invitations/[invitationId]/reinvite
+ * - Resend invitation
+ */ 

package/dist/handlers/invitations.d.ts

@@ -0,0 +1,9 @@
+import { NextRequest } from 'next/server';
+export declare function handleGetInvitationsByTarget(request: NextRequest): Promise<import("next/server").NextResponse<unknown>>;
+export declare function handleGetInvitation(request: NextRequest, invitationId: string): Promise<import("next/server").NextResponse<unknown>>;
+export declare function handleRevokeInvitation(request: NextRequest, invitationId: string): Promise<import("next/server").NextResponse<unknown>>;
+export declare function handleAcceptInvitations(request: NextRequest): Promise<import("next/server").NextResponse<unknown>>;
+export declare function handleGetInvitationsByGroup(request: NextRequest, groupType: string, groupId: string): Promise<import("next/server").NextResponse<unknown>>;
+export declare function handleDeleteInvitationsByGroup(request: NextRequest, groupType: string, groupId: string): Promise<import("next/server").NextResponse<unknown>>;
+export declare function handleReinvite(request: NextRequest, invitationId: string): Promise<import("next/server").NextResponse<unknown>>;
+//# 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,WAAW,EAAE,MAAM,aAAa,CAAC;AAK1C,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,WAAW,wDAuCtE;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,wDAgCnF;AAED,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,wDA8BtF;AAED,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,WAAW,wDAmDjE;AAED,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,wDAmCzG;AAED,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,wDAmC5G;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,wDA8B9E"}

package/dist/handlers/invitations.js

@@ -0,0 +1,400 @@
+"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) {
+    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, 6, , 7]);
+                    if (request.method !== 'GET') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Method not allowed', 405)];
+                    }
+                    config = (0, config_1.getVortexConfig)(request);
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request)];
+                case 1:
+                    user = _a.sent();
+                    if (!config.canAccessInvitationsByTarget) return [3 /*break*/, 3];
+                    return [4 /*yield*/, config.canAccessInvitationsByTarget(request, user)];
+                case 2:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied', 403)];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    if (!user) {
+                        // If no access control hook is configured, require authentication
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 4;
+                case 4:
+                    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)('targetType and targetValue query parameters are required', 400)];
+                    }
+                    if (!['email', 'username', 'phoneNumber'].includes(targetType)) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('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 5:
+                    invitations = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)({ invitations: invitations })];
+                case 6:
+                    error_1 = _a.sent();
+                    console.error('Error in handleGetInvitationsByTarget:', error_1);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)('An error occurred while processing your request', 500)];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleGetInvitation(request, invitationId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sanitizedId, config, user, hasAccess, vortex, invitation, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 6, , 7]);
+                    if (request.method !== 'GET') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Method not allowed', 405)];
+                    }
+                    sanitizedId = (0, utils_1.sanitizeInput)(invitationId);
+                    if (!sanitizedId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Invalid invitation ID', 400)];
+                    }
+                    config = (0, config_1.getVortexConfig)(request);
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request)];
+                case 1:
+                    user = _a.sent();
+                    if (!config.canAccessInvitation) return [3 /*break*/, 3];
+                    return [4 /*yield*/, config.canAccessInvitation(request, user, { invitationId: sanitizedId })];
+                case 2:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied', 403)];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 4;
+                case 4:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.getInvitation(sanitizedId)];
+                case 5:
+                    invitation = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(invitation)];
+                case 6:
+                    error_2 = _a.sent();
+                    console.error('Error in handleGetInvitation:', error_2);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)('An error occurred while processing your request', 500)];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleRevokeInvitation(request, invitationId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sanitizedId, config, user, hasAccess, vortex, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 6, , 7]);
+                    if (request.method !== 'DELETE') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Method not allowed', 405)];
+                    }
+                    sanitizedId = (0, utils_1.sanitizeInput)(invitationId);
+                    if (!sanitizedId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Invalid invitation ID', 400)];
+                    }
+                    config = (0, config_1.getVortexConfig)(request);
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request)];
+                case 1:
+                    user = _a.sent();
+                    if (!config.canDeleteInvitation) return [3 /*break*/, 3];
+                    return [4 /*yield*/, config.canDeleteInvitation(request, user, { invitationId: sanitizedId })];
+                case 2:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied', 403)];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 4;
+                case 4:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.revokeInvitation(sanitizedId)];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)({ success: true })];
+                case 6:
+                    error_3 = _a.sent();
+                    console.error('Error in handleRevokeInvitation:', error_3);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)('An error occurred while processing your request', 500)];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleAcceptInvitations(request) {
+    return __awaiter(this, void 0, void 0, function () {
+        var body, invitationIds, target, sanitizedIds, config, user, hasAccess, vortex, result, error_4;
+        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)('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)('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)('Invalid invitation IDs provided', 400)];
+                    }
+                    if (!target.type || !target.value) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('target must have type and value properties', 400)];
+                    }
+                    if (!['email', 'username', 'phoneNumber'].includes(target.type)) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('target.type must be email, username, or phoneNumber', 400)];
+                    }
+                    config = (0, config_1.getVortexConfig)(request);
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request)];
+                case 2:
+                    user = _a.sent();
+                    if (!config.canAcceptInvitations) return [3 /*break*/, 4];
+                    return [4 /*yield*/, config.canAcceptInvitations(request, user, { invitationIds: sanitizedIds, target: target })];
+                case 3:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied', 403)];
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('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.acceptInvitations(sanitizedIds, {
+                            type: target.type,
+                            value: (0, utils_1.sanitizeInput)(target.value) || target.value
+                        })];
+                case 6:
+                    result = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(result)];
+                case 7:
+                    error_4 = _a.sent();
+                    console.error('Error in handleAcceptInvitations:', error_4);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)('An error occurred while processing your request', 500)];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleGetInvitationsByGroup(request, groupType, groupId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sanitizedGroupType, sanitizedGroupId, config, user, hasAccess, vortex, invitations, error_5;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 6, , 7]);
+                    if (request.method !== 'GET') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Method not allowed', 405)];
+                    }
+                    sanitizedGroupType = (0, utils_1.sanitizeInput)(groupType);
+                    sanitizedGroupId = (0, utils_1.sanitizeInput)(groupId);
+                    if (!sanitizedGroupType || !sanitizedGroupId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Invalid group parameters', 400)];
+                    }
+                    config = (0, config_1.getVortexConfig)(request);
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request)];
+                case 1:
+                    user = _a.sent();
+                    if (!config.canAccessInvitationsByGroup) return [3 /*break*/, 3];
+                    return [4 /*yield*/, config.canAccessInvitationsByGroup(request, user, {
+                            groupType: sanitizedGroupType,
+                            groupId: sanitizedGroupId
+                        })];
+                case 2:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied', 403)];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 4;
+                case 4:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.getInvitationsByGroup(sanitizedGroupType, sanitizedGroupId)];
+                case 5:
+                    invitations = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)({ invitations: invitations })];
+                case 6:
+                    error_5 = _a.sent();
+                    console.error('Error in handleGetInvitationsByGroup:', error_5);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)('An error occurred while processing your request', 500)];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleDeleteInvitationsByGroup(request, groupType, groupId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sanitizedGroupType, sanitizedGroupId, config, user, hasAccess, vortex, error_6;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 6, , 7]);
+                    if (request.method !== 'DELETE') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Method not allowed', 405)];
+                    }
+                    sanitizedGroupType = (0, utils_1.sanitizeInput)(groupType);
+                    sanitizedGroupId = (0, utils_1.sanitizeInput)(groupId);
+                    if (!sanitizedGroupType || !sanitizedGroupId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Invalid group parameters', 400)];
+                    }
+                    config = (0, config_1.getVortexConfig)(request);
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request)];
+                case 1:
+                    user = _a.sent();
+                    if (!config.canDeleteInvitationsByGroup) return [3 /*break*/, 3];
+                    return [4 /*yield*/, config.canDeleteInvitationsByGroup(request, user, {
+                            groupType: sanitizedGroupType,
+                            groupId: sanitizedGroupId
+                        })];
+                case 2:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied', 403)];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 4;
+                case 4:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.deleteInvitationsByGroup(sanitizedGroupType, sanitizedGroupId)];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)({ success: true })];
+                case 6:
+                    error_6 = _a.sent();
+                    console.error('Error in handleDeleteInvitationsByGroup:', error_6);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)('An error occurred while processing your request', 500)];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleReinvite(request, invitationId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sanitizedId, config, user, hasAccess, vortex, invitation, error_7;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 6, , 7]);
+                    if (request.method !== 'POST') {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Method not allowed', 405)];
+                    }
+                    sanitizedId = (0, utils_1.sanitizeInput)(invitationId);
+                    if (!sanitizedId) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Invalid invitation ID', 400)];
+                    }
+                    config = (0, config_1.getVortexConfig)(request);
+                    return [4 /*yield*/, (0, config_1.authenticateRequest)(request)];
+                case 1:
+                    user = _a.sent();
+                    if (!config.canReinvite) return [3 /*break*/, 3];
+                    return [4 /*yield*/, config.canReinvite(request, user, { invitationId: sanitizedId })];
+                case 2:
+                    hasAccess = _a.sent();
+                    if (!hasAccess) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied', 403)];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    if (!user) {
+                        return [2 /*return*/, (0, utils_1.createErrorResponse)('Access denied. Configure access control hooks for invitation endpoints.', 403)];
+                    }
+                    _a.label = 4;
+                case 4:
+                    vortex = new vortex_node_22_sdk_1.Vortex(config.apiKey);
+                    return [4 /*yield*/, vortex.reinvite(sanitizedId)];
+                case 5:
+                    invitation = _a.sent();
+                    return [2 /*return*/, (0, utils_1.createApiResponse)(invitation)];
+                case 6:
+                    error_7 = _a.sent();
+                    console.error('Error in handleReinvite:', error_7);
+                    return [2 /*return*/, (0, utils_1.createErrorResponse)('An error occurred while processing your request', 500)];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}

package/dist/handlers/jwt.d.ts

@@ -0,0 +1,3 @@
+import { NextRequest } from 'next/server';
+export declare function handleJwtGeneration(request: NextRequest): Promise<import("next/server").NextResponse<unknown>>;
+//# 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,WAAW,EAAE,MAAM,aAAa,CAAC;AAK1C,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,WAAW,wDAgC7D"}