@teamvortexsoftware/vortex-node-22-sdk 0.0.3

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2025 Vortex Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,298 @@
+# Vortex NodeJS SDK
+
+This package provides the Vortex Node/Typescript SDK.
+
+With this module, you can both generate a JWT for use with the Vortex Widget and make API calls to the Vortex API.
+
+## Use Cases and Examples
+
+### Install the NodeJS SDK
+
+To install the SDK, simply run the following in your NodeJS backend repo:
+
+```sh
+cd your-repo
+npm install --save @teamvortexsoftware/vortex-node-22-sdk
+```
+
+Once you have the SDK, [login](https://admin.vortexsoftware.com/signin) to Vortex and [create an API Key](https://admin.vortexsoftware.com/members/api-keys). Keep your API key safe! Vortex does not store the API key and it is not retrievable once it has been created. Also, it should be noted that the API key you use is scoped to the environment you're targeting. The environment is implied based on the API key used to sign JWTs and to make API requests.
+
+Your API key is used to 
+- Sign JWTs for use with the Vortex Widget
+- Make API calls against the [Vortex API](https://api.vortexsoftware.com/api)
+
+### Generate a JWT for use with the Vortex Widget
+
+Let's assume you have an express powered API and a user that is looking to invite others and you have a Vortex widget embedded on a component in your frontend codebase. Your frontend will need to provide a JWT to the Vortex widget which allows Vortex to validate the user making the request.
+
+You could populate the JWT in some set of initial data that your application already provides (recommended) or you could create an endpoint specifically to fetch the JWT on demand for use with the widget. For the purposes of this example, we'll create an endpoint to fetch the JWT.
+
+```ts
+const express = require('express');
+const app = express();
+const port = 3000;
+
+// This is the id of the user in your system.
+const userId = 'users-id-in-my-system';
+
+// These identifiers are associated with users in your system.
+const identifiers = [
+  { type: 'email', value: 'users@emailaddress.com' },
+  { type: 'email', value: 'someother@address.com' },
+  { type: 'sms', value: '18008675309' }
+];
+
+// groups are specific to your product. This list should be the groups that the current requesting user is a part of. It is up to you to define them if you so choose. Based on the values here, we can determine whether or not the user is allowed to invite others to a particular group
+const groups = [
+  { type: 'workspace', id: 'some-workspace-id', name: 'The greatest workspace...pause...in the world' },
+  { type: 'document', id: 'some-document-id', name: 'Ricky\'s grade 10 word papers' },
+  { type: 'document', id: 'another-document-id', name: 'Sunnyvale bylaws' }
+];
+
+// If your product has the concept of user roles (admin, guest, member, etc), provide it here
+const role = 'admin';
+
+// Provide your API key however you see fit.
+const vortex = new Vortex(process.env.VORTEX_API_KEY);
+
+app.get('/vortex-jwt', (req, res) => {
+  res.setHeader('Content-Type', 'application/json');
+  res.end(JSON.stringify({ jwt: vortex.generateJwt({
+    userId,
+    identifiers,
+    groups,
+    role
+  })}));
+})
+
+app.listen(port, () => {
+  console.log(`Example app listening on port ${port}. Fetch example JWT by hitting /vortex-jwt`)
+})
+```
+
+Now, you can utilize that JWT endpoint in conjuction with the Vortex widget
+
+Here's an example hook:
+
+```ts
+import { useEffect, useState } from "react";
+
+export function useVortexJwt() {
+  const [data, setData] = useState<any>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function fetchJwt() {
+      try {
+        const res = await fetch("/vortex-jwt");
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const json = await res.json();
+        if (!cancelled) setData(json);
+      } catch (err) {
+        if (!cancelled) setError(err as Error);
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    }
+
+    fetchJwt();
+
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  return { data, loading, error };
+}
+```
+
+Now here is that hook in use in conjuction with a Vortex widget:
+
+```ts
+function InviteWrapperComponent() {
+  const { data, loading, error } = useVortexJwt();
+
+  if (loading) return <p>Loading...</p>;
+  if (error) return <p>Error: {error.message}</p>;
+  const widgetId = 'this-id-comes-from-the-widget-configurator';
+  const { jwt } = data;
+  return (<VortexInvite
+    widgetId={widgetId}
+    jwt={jwt}
+    group={{ id: "workspace", type: "some-workspace-id", name: "The greatest workspace...pause...in the world" }}
+    templateVariables={{
+      group_name: "The greatest workspace...pause...in the world",
+      inviter_name: "James Lahey",
+      group_member_count: "23",
+      company_name: "Sunnyvale, Inc"
+    }}
+  />);
+}
+```
+### Fetch an invitation by ID
+
+When a shared invitation link or an invitaion link sent via email is clicked, the user who clicks it is redirected to the landing page you set in the widget configurator. For instance, if you set http://localhost:3000/invite/landing as the landing page and the invitation being clicked has an id of deadbeef-dead-4bad-8dad-c001d00dc0de, the user who clicks the invitation link will land on http://localhost:3000/invite/landing?invitationId=deadbeef-dead-4bad-8dad-c001d00dc0de
+
+Before the user signs up, you may want to display the invitation. To do this, your backend will need to fetch it from our API.
+
+```ts
+app.get('/invite/landing', async (req, res) => {
+  const invitationId = req.query?.invitationId;
+  if (!invitationId) {
+    // gracefully handle this situation
+    return res.status(400).send('Invitation ID required');
+  }
+  const invitation = await vortex.getInvitation(invitationId);
+
+  if (!invitation) {
+    return res.status(404).send('Not found');
+  }
+
+  // you probably want to do something with the invitation at this point.
+  // For example, you could render the invitation as HTML and ask the user
+  // to signup and then accept the invite automatically on join.
+  // For the sake of simplicity, we'll simply return the raw JSON
+  res.setHeader('Content-Type', 'application/json');
+  res.end(JSON.stringify(invitation));
+})
+```
+### View invitations by target (email address for example)
+
+Depending on your use case, you may want to accept all outstanding invitations to a given user when they sign up for your service. If you don't want to auto accept, you may want to present the new user with a list of all invitations that target them. Either way, the example below shows how you fetch these invitations once you know how to identify (via email, sms or others in the future) a new user to your product.
+
+```ts
+app.get('/invitations/by-email', async (req, res) => {
+  const email = req.query?.email;
+  if (!email) {
+    // gracefully handle this situation
+    return res.status(400).send('Email is required');
+  }
+  const invitations = await vortex.getInvitationsByTarget('email', email);
+
+  if (!invitations || !invitations.length) {
+    return res.status(404).send('Not found');
+  }
+
+  // you probably want to do something with the invitation at this point.
+  // For example, you could render the invitation as HTML and ask the user
+  // to signup and then accept the invite automatically on join.
+  // For the sake of simplicity, we'll simply return the raw JSON
+  res.setHeader('Content-Type', 'application/json');
+  res.end(JSON.stringify(invitations));
+})
+```
+### Accept invitations
+
+This is how you'd accept one or more invitations with the SDK. You want this as part of your signup flow more than likely. When someone clicks on an invitation link, we redirect to the landing page you specified in the widget configuration. Ultimately, the user will sign up with your service and that is when you create the relationship between the newly created user in your system and whatever grouping defined in the invitation itself.
+
+Illustrated in the example below, you will see how to accept one or more invitations. For the sake of the example, we'll assume you want to accept all open invitations when a user signs up to your service. The example will leverage the previous example's call to getInvitationsByTarget with the acceptInvitations call.
+
+```ts
+app.post('/signup', async (req, res) => {
+  const email = req.body.email;
+  if (!email) {
+    // gracefully handle this situation
+    return res.status(400).send('Email is required');
+  }
+
+  // YOUR signup logic, whatever it may be
+  await myApp.doSignupLogic(email); 
+
+  // you may want to do this even if the user is signing up without clicking an invitaiton link
+  const invitations = await vortex.getInvitationsByTarget('email', email);
+
+  // Assume that your application may pass the original invitationId from the 
+  // landing page registered with the configured widget
+  const invitationId = req.body.invitationId;
+
+  const uniqueInvitationIds = invitations.map((invitation) => invitation.id);
+  if (invitationId && uniqueInvitationIds.indexOf(invitationId) === -1) {
+    uniqueInvitationIds.push(invitationId);
+  }
+
+  const acceptedInvitations = await vortex.acceptInvitations(
+    uniqueInvitationIds,
+    { type: 'email', value: email }
+  );
+  
+  // continue with post-signup activity. perhaps redirect to your logged in landing page
+
+  res.redirect(302, '/app');
+})
+```
+### Fetch invitations by group
+
+Perhaps you want to allow your users to see all outstanding invitations for a group that they are a member of. Or perhaps you want this exclusively for admins of the group. However you choose to do it, this SDK feature will allow you to fetch all outstanding invitations for a group.
+
+```ts
+app.get('/invitations/by-group', async (req, res) => {
+  const { groupType, groupId } = req.query;
+  if (!groupType || !groupId) {
+    // gracefully handle this situation
+    return res.status(400).send('Required: groupType and groupId');
+  }
+
+  const invitations = await vortex.getInvitationsByGroup(groupType, groupId);
+
+  res.setHeader('Content-Type', 'application/json');
+  res.end(JSON.stringify(invitations));
+})
+```
+### Reinvite
+
+You may want to allow your users to resend an existing invitation. Allowing for this will increase the conversion chances of a stale invitation. Perhaps you display a list of outstanding invites and allow for a reinvite based on that list.
+
+```ts
+app.post('/invitations/reinvite', async (req, res) => {
+  const { invitationId } = req.body;
+  if (!invitationId) {
+    // gracefully handle this situation
+    return res.status(400).send('Required: invitationId');
+  }
+
+  const invitation = await vortex.reinvite(invitationId);
+
+  res.setHeader('Content-Type', 'application/json');
+  res.end(JSON.stringify(invitation));
+})
+```
+### Revoke invitation
+
+In addition to reinvite, you may want to present your users (or perhaps just admins) with the ability to revoke outstanding invitations.
+
+```ts
+app.post('/invitations/revoke', async (req, res) => {
+  const { invitationId } = req.body;
+  if (!invitationId) {
+    // gracefully handle this situation
+    return res.status(400).send('Required: invitationId');
+  }
+
+  await vortex.revokeInvitation(invitationId);
+
+  res.setHeader('Content-Type', 'application/json');
+  res.end(JSON.stringify({}));
+})
+```
+### Delete invitations by group
+
+Your product may allow for your users to delete the underlying resource that is tied to one or more invitations. For instance, say your product has the concept of a 'workspace' and your invitations are created specifying a particular workspace associated with each invitation. Then, at some point in the future, the admin of the workspace decides to delete it. This means all invitations associated with that workspace are now invalid and need to be removed so that reminders don't go out for any outstanding invite to the now deleted workspace.
+
+Here is how to clean them up when the workspace is deleted.
+```ts
+app.delete('/workspace/:workspaceId', async (req, res) => {
+  const { workspaceId } = req.params;
+  if (!workspaceId) {
+    // gracefully handle this situation
+    return res.status(400).send('Required: workspaceId');
+  }
+
+  await vortex.deleteInvitationsByGroup('workspace', workspaceId);
+
+  res.setHeader('Content-Type', 'application/json');
+  res.end(JSON.stringify({}));
+})
+```

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './vortex';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/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("./vortex"), exports);
+__exportStar(require("./types"), exports);

package/dist/types.d.ts

@@ -0,0 +1,46 @@
+export type InvitationTarget = {
+    type: 'email' | 'sms';
+    value: string;
+};
+export type InvitationGroup = {
+    id: string;
+    type: string;
+    name: string;
+};
+export type InvitationAcceptance = {
+    id: string;
+    accountId: string;
+    projectId: string;
+    acceptedAt: string;
+    target: InvitationTarget;
+};
+export type InvitationResult = {
+    id: string;
+    accountId: string;
+    clickThroughs: number;
+    configurationAttributes: Record<string, any> | null;
+    attributes: Record<string, any> | null;
+    createdAt: string;
+    deactivated: boolean;
+    deliveryCount: number;
+    deliveryTypes: ('email' | 'sms' | 'share')[];
+    foreignCreatorId: string;
+    invitationType: 'single_use' | 'multi_use';
+    modifiedAt: string | null;
+    status: 'queued' | 'sending' | 'delivered' | 'accepted' | 'shared' | 'unfurled' | 'accepted_elsewhere';
+    target: InvitationTarget[];
+    views: number;
+    widgetConfigurationId: string;
+    projectId: string;
+    groups: InvitationGroup[];
+    accepts: InvitationAcceptance[];
+};
+export type AcceptInvitationRequest = {
+    invitationIds: string[];
+    target: InvitationTarget;
+};
+export type ApiResponseJson = InvitationResult | {
+    invitations: InvitationResult[];
+} | {};
+export type ApiRequestBody = AcceptInvitationRequest | null;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,GAAG,KAAK,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IACpD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC,EAAE,CAAC;IAC7C,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,YAAY,GAAG,WAAW,CAAC;IAC3C,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,oBAAoB,CAAC;IACvG,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,qBAAqB,EAAE,MAAM,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,OAAO,EAAE,oBAAoB,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG;IAAE,WAAW,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAAG,EAAE,CAAC;AAE1F,MAAM,MAAM,cAAc,GAAG,uBAAuB,GAAG,IAAI,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vortex.d.ts

@@ -0,0 +1,35 @@
+import { ApiRequestBody, ApiResponseJson, InvitationResult } from './types';
+export declare class Vortex {
+    private apiKey;
+    constructor(apiKey: string);
+    generateJwt({ userId, identifiers, groups, role, }: {
+        userId: string;
+        identifiers: {
+            type: 'email' | 'sms';
+            value: string;
+        }[];
+        groups: {
+            type: string;
+            id: string;
+            name: string;
+        }[];
+        role?: string;
+    }): string;
+    vortexApiRequest(options: {
+        method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+        path: string;
+        body?: ApiRequestBody;
+        queryParams?: Record<string, string | number | boolean>;
+    }): Promise<ApiResponseJson>;
+    getInvitationsByTarget(targetType: 'email' | 'username' | 'phoneNumber', targetValue: string): Promise<InvitationResult[]>;
+    getInvitation(invitationId: string): Promise<InvitationResult>;
+    revokeInvitation(invitationId: string): Promise<{}>;
+    acceptInvitations(invitationIds: string[], target: {
+        type: 'email' | 'username' | 'phoneNumber';
+        value: string;
+    }): Promise<InvitationResult>;
+    deleteInvitationsByGroup(groupType: string, groupId: string): Promise<{}>;
+    getInvitationsByGroup(groupType: string, groupId: string): Promise<InvitationResult[]>;
+    reinvite(invitationId: string): Promise<InvitationResult>;
+}
+//# sourceMappingURL=vortex.d.ts.map

package/dist/vortex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vortex.d.ts","sourceRoot":"","sources":["../src/vortex.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,gBAAgB,EAA2B,MAAM,SAAS,CAAC;AAErG,qBAAa,MAAM;IACL,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC,WAAW,CAAC,EACV,MAAM,EACN,WAAW,EACX,MAAM,EACN,IAAI,GACL,EAAE;QACD,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE;YAAE,IAAI,EAAE,OAAO,GAAG,KAAK,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QACxD,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QACrD,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,GAAG,MAAM;IA4CJ,gBAAgB,CAAC,OAAO,EAAE;QAC9B,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;QAC1C,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,cAAc,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;KACzD,GAAG,OAAO,CAAC,eAAe,CAAC;IAuBtB,sBAAsB,CAAC,UAAU,EAAE,OAAO,GAAG,UAAU,GAAG,aAAa,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAY1H,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAO9D,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;IAOnD,iBAAiB,CACrB,aAAa,EAAE,MAAM,EAAE,EACvB,MAAM,EAAE;QAAE,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,aAAa,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GACpE,OAAO,CAAC,gBAAgB,CAAC;IAYtB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;IAOzE,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAQtF,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAMhE"}

package/dist/vortex.js

@@ -0,0 +1,217 @@
+"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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vortex = void 0;
+var node_crypto_1 = __importDefault(require("node:crypto"));
+var uuid_1 = require("uuid");
+var Vortex = /** @class */ (function () {
+    function Vortex(apiKey) {
+        this.apiKey = apiKey;
+    }
+    Vortex.prototype.generateJwt = function (_a) {
+        var userId = _a.userId, identifiers = _a.identifiers, groups = _a.groups, role = _a.role;
+        var _b = this.apiKey.split('.'), prefix = _b[0], encodedId = _b[1], key = _b[2]; // prefix is just VRTX
+        if (!prefix || !encodedId || !key) {
+            throw new Error('Invalid API key format');
+        }
+        if (prefix !== 'VRTX') {
+            throw new Error('Invalid API key prefix');
+        }
+        var id = (0, uuid_1.stringify)(Buffer.from(encodedId, 'base64url'));
+        var expires = Math.floor(Date.now() / 1000) + 3600;
+        // 🔐 Step 1: Derive signing key from API key + ID
+        var signingKey = node_crypto_1.default.createHmac('sha256', key).update(id).digest(); // <- raw Buffer
+        // 🧱 Step 2: Build header + payload
+        var header = {
+            iat: Math.floor(Date.now() / 1000),
+            alg: 'HS256',
+            typ: 'JWT',
+            kid: id,
+        };
+        var payload = {
+            userId: userId,
+            groups: groups,
+            role: role,
+            expires: expires,
+            identifiers: identifiers,
+        };
+        // 🧱 Step 3: Base64URL encode
+        var headerB64 = Buffer.from(JSON.stringify(header)).toString('base64url');
+        var payloadB64 = Buffer.from(JSON.stringify(payload)).toString('base64url');
+        // 🧾 Step 4: Sign
+        var toSign = "".concat(headerB64, ".").concat(payloadB64);
+        var signature = Buffer.from(node_crypto_1.default.createHmac('sha256', signingKey).update(toSign).digest()).toString('base64url');
+        var jwt = "".concat(toSign, ".").concat(signature);
+        return jwt;
+    };
+    Vortex.prototype.vortexApiRequest = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var method, path, body, queryParams, url, results, errorBody;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        method = options.method, path = options.path, body = options.body, queryParams = options.queryParams;
+                        url = new URL("".concat(process.env.VORTEX_API_BASE_URL || 'https://api.vortexsoftware.com').concat(path));
+                        if (queryParams) {
+                            Object.entries(queryParams).forEach(function (_a) {
+                                var key = _a[0], value = _a[1];
+                                url.searchParams.append(key, String(value));
+                            });
+                        }
+                        return [4 /*yield*/, fetch(url.toString(), {
+                                method: method,
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                    'x-api-key': this.apiKey,
+                                },
+                                body: body ? JSON.stringify(body) : undefined,
+                            })];
+                    case 1:
+                        results = _a.sent();
+                        if (!!results.ok) return [3 /*break*/, 3];
+                        return [4 /*yield*/, results.text()];
+                    case 2:
+                        errorBody = _a.sent();
+                        throw new Error("Vortex API request failed: ".concat(results.status, " ").concat(results.statusText, " - ").concat(errorBody));
+                    case 3: return [2 /*return*/, results.json()];
+                }
+            });
+        });
+    };
+    Vortex.prototype.getInvitationsByTarget = function (targetType, targetValue) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.vortexApiRequest({
+                            method: 'GET',
+                            path: '/api/v1/invitations?targetType',
+                            queryParams: {
+                                targetType: targetType,
+                                targetValue: targetValue,
+                            }
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.invitations];
+                }
+            });
+        });
+    };
+    Vortex.prototype.getInvitation = function (invitationId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.vortexApiRequest({
+                        method: 'GET',
+                        path: "/api/v1/invitations/".concat(invitationId),
+                    })];
+            });
+        });
+    };
+    Vortex.prototype.revokeInvitation = function (invitationId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.vortexApiRequest({
+                        method: 'DELETE',
+                        path: "/api/v1/invitations/".concat(invitationId),
+                    })];
+            });
+        });
+    };
+    Vortex.prototype.acceptInvitations = function (invitationIds, target) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.vortexApiRequest({
+                            method: 'POST',
+                            body: {
+                                invitationIds: invitationIds,
+                                target: target,
+                            },
+                            path: "/api/v1/invitations/accept",
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    Vortex.prototype.deleteInvitationsByGroup = function (groupType, groupId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.vortexApiRequest({
+                        method: 'DELETE',
+                        path: "/api/v1/invitations/by-group/".concat(groupType, "/").concat(groupId),
+                    })];
+            });
+        });
+    };
+    Vortex.prototype.getInvitationsByGroup = function (groupType, groupId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.vortexApiRequest({
+                            method: 'GET',
+                            path: "/api/v1/invitations/by-group/".concat(groupType, "/").concat(groupId),
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.invitations];
+                }
+            });
+        });
+    };
+    Vortex.prototype.reinvite = function (invitationId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.vortexApiRequest({
+                        method: 'POST',
+                        path: "/api/v1/invitations/".concat(invitationId, "/reinvite"),
+                    })];
+            });
+        });
+    };
+    return Vortex;
+}());
+exports.Vortex = Vortex;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@teamvortexsoftware/vortex-node-22-sdk",
+  "description": "Vortex Node 22 SDK",
+  "author": "@teamvortexsoftware",
+  "version": "0.0.3",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build:stg": "pnpm run distclean && pnpm run build && mkdir -p dist.d/stg && mv dist dist.d/stg && echo && echo 'Build in ./dist.d/stg'",
+    "prepublish:stg": "cp ./LICENSE ./README.md ./dist.d/stg/ && jq '.name = \"@teamvortexsoftware/vortex-node-22-sdk-stg\" | .description = \"Vortex Node 22 SDK (STG)\" | del(.scripts.prepack)' ./package.json > ./dist.d/stg/package.json",
+    "publish:stg": "pnpm run prepublish:stg && npm publish  --userconfig ../../.npmrc --access restricted ./dist.d/stg",
+    "build:prod": "pnpm run distclean && pnpm run build && mkdir -p dist.d/prod && mv dist dist.d/prod && echo && echo 'Build in ./dist.d/prod'",
+    "prepublish:prod": "cp ./LICENSE ./README.md ./dist.d/prod/ && jq 'del(.scripts.prepack)' ./package.json > ./dist.d/prod/package.json",
+    "publish:prod": "pnpm run prepublish:prod && npm publish  --userconfig ../../.npmrc --access public ./dist.d/prod",
+    "check-types": "tsc --noEmit",
+    "distclean": "rm -rf ./dist ./dist.d",
+    "clean": "rm -rf ./dist",
+    "dev": "",
+    "test": "jest",
+    "package": "pnpm run build && cd dist/vortex-node-22-sdk && npm pack",
+    "build": "tsc -b tsconfig.json"
+  },
+  "jest": {
+    "rootDir": "__tests__",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "coverage",
+    "testEnvironment": "node"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@jest/globals": "29.7.0",
+    "@teamvortexsoftware/eslint-config": "workspace:*",
+    "@teamvortexsoftware/typescript-config": "workspace:*",
+    "eslint": "^9.24.0",
+    "jest": "29.7.0",
+    "typescript-eslint": "^8.30.1"
+  },
+  "dependencies": {
+    "uuid": "^13.0.0"
+  }
+}