@turnkey/sdk-server
Version:
JavaScript Server SDK
294 lines (291 loc) • 10.8 kB
JavaScript
'use server';
import { FilterType } from './__types__/base.mjs';
import { TurnkeyServerSDK } from './sdk-client.mjs';
import { DEFAULT_ETHEREUM_ACCOUNTS, DEFAULT_SOLANA_ACCOUNTS } from './turnkey-helpers.mjs';
import { WalletType } from '@turnkey/wallet-stamper';
const turnkeyClient = new TurnkeyServerSDK({
apiBaseUrl: process.env.NEXT_PUBLIC_BASE_URL,
defaultOrganizationId: process.env.NEXT_PUBLIC_ORGANIZATION_ID,
apiPrivateKey: process.env.TURNKEY_API_PRIVATE_KEY,
apiPublicKey: process.env.TURNKEY_API_PUBLIC_KEY,
});
async function sendCredential(request) {
try {
const response = await turnkeyClient.apiClient().emailAuth({
email: request.email,
targetPublicKey: request.targetPublicKey,
organizationId: request.suborgID,
...(request.apiKeyName && { apiKeyName: request.apiKeyName }),
...(request.sessionLengthSeconds !== undefined && {
expirationSeconds: request.sessionLengthSeconds.toString(),
}),
...(request.invalidateExisting && {
invalidateExisting: request.invalidateExisting,
}),
...(request.emailCustomization && {
emailCustomization: request.emailCustomization,
}),
...(request.sendFromEmailAddress && {
sendFromEmailAddress: request.sendFromEmailAddress,
}),
});
if (!response.userId) {
throw new Error("Expected a non-null userId.");
}
}
catch (error) {
console.error(error);
return undefined;
}
}
async function sendOtp(request) {
try {
const response = await turnkeyClient.apiClient().initOtp({
contact: request.contact,
otpType: request.otpType,
...(request.emailCustomization && {
emailCustomization: request.emailCustomization,
}),
...(request.sendFromEmailAddress && {
sendFromEmailAddress: request.sendFromEmailAddress,
}),
...(request.sendFromEmailSenderName && {
sendFromEmailSenderName: request.sendFromEmailSenderName,
}),
...(request.userIdentifier && { userIdentifier: request.userIdentifier }),
...(request.customSmsMessage && {
smsCustomization: { template: request.customSmsMessage },
}),
...(request.otpLength && {
otpLength: request.otpLength,
}),
alphanumeric: request.alphanumeric ?? true,
});
if (!response.otpId) {
throw new Error("Expected a non-null otpId.");
}
return response;
}
catch (error) {
console.error(error);
return undefined;
}
}
async function verifyOtp(request) {
try {
const response = await turnkeyClient.apiClient().verifyOtp({
otpId: request.otpId,
otpCode: request.otpCode,
...(request.sessionLengthSeconds !== undefined && {
expirationSeconds: request.sessionLengthSeconds.toString(),
}),
});
const { verificationToken } = response;
if (!verificationToken) {
throw new Error("Expected a non-null value for verificationToken");
}
return response;
}
catch (error) {
console.error(error);
return undefined;
}
}
async function otpLogin(request) {
try {
const response = await turnkeyClient.apiClient().otpLogin({
organizationId: request.suborgID,
verificationToken: request.verificationToken,
publicKey: request.publicKey,
...(request.sessionLengthSeconds !== undefined && {
expirationSeconds: request.sessionLengthSeconds.toString(),
}),
});
const { session } = response;
if (!session) {
throw new Error("Expected a non-null value for session");
}
return response;
}
catch (error) {
console.error(error);
return undefined;
}
}
async function oauthLogin(request) {
try {
const response = await turnkeyClient.apiClient().oauthLogin({
organizationId: request.suborgID,
oidcToken: request.oidcToken,
publicKey: request.publicKey,
...(request.sessionLengthSeconds !== undefined && {
expirationSeconds: request.sessionLengthSeconds.toString(),
}),
});
const { session } = response;
if (!session) {
throw new Error("Expected a non-null value for session");
}
return response;
}
catch (error) {
console.error(error);
return undefined;
}
}
async function createOauthProviders(request) {
// Create Oauth Providers can be called by the parent targeting the suborg only when the following cases are true:
// 1. the oAuth issuer is Google,
// 2. the oAuth issuer has verified the email in the token
// 3. the email in the token matches the email that the user has already has logged in with
try {
const response = await turnkeyClient.apiClient().createOauthProviders({
organizationId: request.organizationId,
userId: request.userId,
oauthProviders: request.oauthProviders,
});
if (!response) {
throw new Error("Expected a non-null response.");
}
return response;
}
catch (error) {
console.error(error);
return undefined;
}
}
async function getUsers(request) {
try {
const response = await turnkeyClient.apiClient().getUsers({
organizationId: request.organizationId,
});
if (!response || !response.users) {
throw new Error("Expected a non-null response with userIds.");
}
return { users: response.users };
}
catch (error) {
console.error(error);
return undefined;
}
}
async function getSuborgs(request) {
const response = await turnkeyClient.apiClient().getSubOrgIds({
organizationId: turnkeyClient.config.defaultOrganizationId,
filterType: request.filterType,
filterValue: request.filterValue,
});
if (!response || !response?.organizationIds) {
throw new Error("Expected a non-null response.");
}
return { organizationIds: response.organizationIds };
}
async function getVerifiedSuborgs(request) {
const response = await turnkeyClient.apiClient().getVerifiedSubOrgIds({
organizationId: turnkeyClient.config.defaultOrganizationId,
filterType: request.filterType,
filterValue: request.filterValue,
});
if (!response || !response?.organizationIds) {
throw new Error("Expected a non-null response.");
}
return { organizationIds: response.organizationIds };
}
async function createSuborg(request) {
try {
const response = await turnkeyClient.apiClient().createSubOrganization({
subOrganizationName: `suborg-${String(Date.now())}`,
rootQuorumThreshold: 1,
rootUsers: [
{
userName: request.email ?? "",
userEmail: request.email ?? "",
...(request.phoneNumber
? { userPhoneNumber: request.phoneNumber }
: {}),
apiKeys: request.wallet
? [
{
apiKeyName: `wallet-auth:${request.wallet.publicKey}`,
publicKey: request.wallet.publicKey,
curveType: request.wallet.type === WalletType.Ethereum
? "API_KEY_CURVE_SECP256K1"
: "API_KEY_CURVE_ED25519",
},
]
: [],
authenticators: request.passkey ? [request.passkey] : [],
oauthProviders: request.oauthProviders ?? [],
},
],
wallet: {
walletName: `Wallet 1`,
accounts: request.customAccounts ?? [
...DEFAULT_ETHEREUM_ACCOUNTS,
...DEFAULT_SOLANA_ACCOUNTS,
],
},
});
if (!response.subOrganizationId) {
throw new Error("Expected a non-null subOrganizationId.");
}
return { subOrganizationId: response.subOrganizationId };
}
catch (error) {
console.error(error);
return undefined;
}
}
async function getOrCreateSuborg(request) {
// First try to get existing suborgs
let suborgResponse;
if (request.filterType === FilterType.Email ||
request.filterType === FilterType.PhoneNumber) {
suborgResponse = await getVerifiedSuborgs({
filterType: request.filterType,
filterValue: request.filterValue,
});
}
else {
suborgResponse = await getSuborgs({
filterType: request.filterType,
filterValue: request.filterValue,
});
}
// If we found existing suborgs, return the first one
if (suborgResponse.organizationIds.length > 0) {
return {
subOrganizationIds: suborgResponse.organizationIds,
};
}
// No existing suborg found - create a new one
const createPayload = {
...(request.additionalData?.email && {
email: request.additionalData.email,
}),
...(request.additionalData?.phoneNumber && {
phoneNumber: request.additionalData.phoneNumber,
}),
...(request.additionalData?.passkey && {
passkey: request.additionalData.passkey,
}),
...(request.additionalData?.oauthProviders && {
oauthProviders: request.additionalData.oauthProviders,
}),
...(request.additionalData?.customAccounts && {
customAccounts: request.additionalData.customAccounts,
}),
...(request.additionalData?.wallet && {
wallet: request.additionalData.wallet,
}),
};
const creationResponse = await createSuborg(createPayload);
if (!creationResponse?.subOrganizationId) {
throw new Error("Suborg creation failed");
}
return {
subOrganizationIds: [creationResponse.subOrganizationId],
};
}
export { createOauthProviders, createSuborg, getOrCreateSuborg, getSuborgs, getUsers, getVerifiedSuborgs, oauthLogin, otpLogin, sendCredential, sendOtp, verifyOtp };
//# sourceMappingURL=actions.mjs.map