@stepzen/sdk 0.11.1 → 1.0.0-alpha.1

package/src/client-v2.ts

@@ -0,0 +1,99 @@
+// Copyright (c) 2020,2021,2022, StepZen, Inc.
+
+import accountCmd from './commands-v2/account'
+import deployCmd from './commands-v2/deploy'
+import listCmd from './commands-v2/list'
+import getPublicAccount from './commands-v2/getPublicAccount'
+import {SDKConfigurationV2, StepZenCredentialsV2} from './shared/types'
+
+export const ensureValidCredentials = async (
+  auth:
+    | {account: string; adminKey: string; deploymentType: string}
+    | {publicAccountToken: string; deploymentType: string},
+  sdkConfig: SDKConfigurationV2,
+) => {
+  let credentials: StepZenCredentialsV2
+
+  if ('publicAccountToken' in auth) {
+    // create an anonymous account and use it to initialize an SDK client instance
+    const {data, error} = await getPublicAccount({
+      token: auth.publicAccountToken,
+      deploymentType: auth.deploymentType,
+      sdkConfig,
+    })
+
+    if (error) {
+      throw new Error(`An unexpected error occurred: ${error.message}`)
+    }
+
+    credentials = data
+  } else {
+    // use the provided account to initialize an SDK client instance
+    const {data, error} = await accountCmd({
+      account: auth.account,
+      adminKey: auth.adminKey,
+      deploymentType: auth.deploymentType,
+      sdkConfig,
+    })
+
+    if (error) {
+      throw new Error(error.message)
+    }
+
+    credentials = data[0]
+  }
+
+  return credentials
+}
+
+export const createSdkClient = async (
+  auth:
+    | {account: string; adminKey: string; deploymentType: string}
+    | {publicAccountToken: string; deploymentType: string},
+  sdkConfig: SDKConfigurationV2,
+) => {
+  const credentials = await ensureValidCredentials(auth, sdkConfig)
+
+  return {
+    get credentials() {
+      // always return a copy to avoid accidential modification by the caller
+      return {...credentials}
+    },
+    deploy: ({
+      endpointName,
+      sdl,
+      folderName,
+      public: _public,
+      endpointType,
+      config,
+    }: {
+      endpointName: string
+      sdl: string
+      folderName?: string
+      public?: boolean
+      endpointType?: string
+      config?: string
+    }) => {
+      return deployCmd({
+        folderName: folderName || 'default',
+        endpointName,
+        public: typeof _public === 'boolean' ? _public : false,
+        endpointType: endpointType || 'dev',
+        sdl,
+        config: config || '{}',
+        account: credentials.account,
+        adminKey: credentials.adminKey,
+        deploymentType: credentials.deploymentType,
+        sdkConfig,
+      })
+    },
+    list: () => {
+      return listCmd({
+        account: credentials.account,
+        adminKey: credentials.adminKey,
+        deploymentType: credentials.deploymentType,
+        sdkConfig,
+      })
+    },
+  }
+}

package/src/commands-v2/account.ts

@@ -0,0 +1,89 @@
+// Copyright (c) 2020,2021,2022, StepZen, Inc.
+
+import {
+  SDKConfigurationV2,
+  StepZenAccountV2,
+  ZenCtlResponseV2,
+} from '../shared/types'
+import {fetchZenCtlGraphQLQuery} from '../shared/graphql-client'
+
+export default async ({
+  account,
+  adminKey,
+  deploymentType,
+  sdkConfig,
+}: {
+  account: string
+  adminKey: string
+  deploymentType: string
+  sdkConfig: SDKConfigurationV2
+}): Promise<ZenCtlResponseV2<StepZenAccountV2[]>> => {
+  const {data, errors} = await fetchZenCtlGraphQLQuery<{
+    accounts: Array<{
+      deploymentType: string
+      account: string
+      ownerEmail: string
+      adminKey: string
+      serviceKey: string
+    }>
+  }>({
+    query: `query (
+      $account: String!
+      $adminKey: String!
+      $deploymentType: String!
+    ) {
+      accounts: account(
+        account: $account
+        adminkey: $adminKey
+        deploymentType: $deploymentType
+      ) {
+        deploymentType: account_deployment_type
+        account: account_name
+        ownerEmail: account_owner_email
+        adminKey: key_value_admin
+        serviceKey: key_value_service
+      }
+    }`,
+    variables: {
+      account,
+      adminKey,
+      deploymentType,
+    },
+    sdkConfig,
+  })
+
+  if (errors) {
+    // strip graphql-specific error details, leave only the message
+    const message = errors
+      .map(({message}) => ({
+        message: message.startsWith(
+          'ERROR: invalid input value for enum zenctl.deployment_type',
+        )
+          ? `Invalid deployment type: ${deploymentType}`
+          : message,
+      }))
+      .join('\n')
+
+    return {
+      data: undefined,
+      error: {
+        message,
+      },
+    }
+  }
+
+  const accounts = data.accounts.filter(Boolean)
+  if (!accounts.length) {
+    return {
+      data: undefined,
+      error: {
+        message: 'Invalid credentials',
+      },
+    }
+  }
+
+  return {
+    data: accounts,
+    error: undefined,
+  }
+}

package/src/commands-v2/deploy.ts

@@ -0,0 +1,144 @@
+// Copyright (c) 2020,2021,2022, StepZen, Inc.
+
+import {
+  SDKConfigurationV2,
+  StepZenEndpointV2,
+  ZenCtlResponseV2,
+} from '../shared/types'
+import {fetchZenCtlGraphQLQuery} from '../shared/graphql-client'
+
+export default async ({
+  account,
+  deploymentType,
+  folderName,
+  endpointName,
+  public: _public,
+  endpointType,
+  sdl,
+  config,
+  adminKey,
+  sdkConfig,
+}: {
+  account: string
+  deploymentType: string
+  folderName: string
+  endpointName: string
+  public: boolean
+  endpointType: string
+  sdl: string
+  config: string
+  adminKey: string
+  sdkConfig: SDKConfigurationV2
+}): Promise<ZenCtlResponseV2<StepZenEndpointV2>> => {
+  const {data, errors} = await fetchZenCtlGraphQLQuery<{
+    endpoints: Array<{
+      account: string
+      deploymentType: string
+      endpointName: string
+      public: boolean
+      endpointType: string
+      folderName: string
+    }>
+  }>({
+    query: `query (
+      $account: String!
+      $deploymentType: String!
+      $folderName: String!
+      $endpointName: String!
+      $public: Boolean!
+      $endpointType: String!
+      $sdl: JSON!
+      $config: JSON!
+      $adminKey: String!
+    ) {
+      endpoints: addEndpoint(
+        account: $account
+        deploymentType: $deploymentType
+        folderName: $folderName
+        endpointName: $endpointName
+        public: $public
+        endpointType: $endpointType
+        sdl: $sdl
+        config: $config
+        adminkey: $adminKey
+      ) {
+        account: account_name
+        deploymentType: deployment_type
+        endpointName: endpoint_name
+        public: endpoint_public
+        endpointType: endpoint_type
+        folderName: folder_name
+      }
+    }`,
+    variables: {
+      account,
+      deploymentType,
+      folderName,
+      endpointName,
+      public: _public,
+      endpointType,
+      sdl,
+      config,
+      adminKey,
+    },
+    sdkConfig,
+  })
+
+  if (errors) {
+    // strip graphql-specific error details, leave only the message
+    const message = errors
+      .map(({message}) => {
+        let newMessage = message
+        if (
+          message.startsWith(
+            'ERROR: invalid input value for enum zenctl.deployment_type',
+          )
+        ) {
+          newMessage =
+            `Invalid deployment type: ${deploymentType}.` +
+            ` Please check the 'deploymentType' parameter.`
+        } else if (
+          message.startsWith(
+            'ERROR: invalid input value for enum zenctl.endpoint_type',
+          )
+        ) {
+          newMessage =
+            `Invalid endpoint type: ${endpointType}.` +
+            ` Please check the 'endpointType' parameter.`
+        } else if (
+          message.startsWith('ERROR: invalid input syntax for type json')
+        ) {
+          newMessage =
+            `Could not parse a string as JSON.` +
+            ` Please check the 'sdl' or 'config' parameters.`
+        }
+
+        return {
+          message: newMessage,
+        }
+      })
+      .join('\n')
+
+    return {
+      data: undefined,
+      error: {
+        message,
+      },
+    }
+  }
+
+  const endpoints = data.endpoints.filter(Boolean)
+  if (!endpoints.length) {
+    return {
+      data: undefined,
+      error: {
+        message: 'Invalid credentials',
+      },
+    }
+  }
+
+  return {
+    data: endpoints[0],
+    error: undefined,
+  }
+}

package/src/commands-v2/getPublicAccount.ts

@@ -0,0 +1,59 @@
+// Copyright (c) 2020,2021,2022, StepZen, Inc.
+
+import {
+  SDKConfigurationV2,
+  StepZenCredentialsV2,
+  ZenCtlResponseV2,
+} from '../shared/types'
+import {fetchPublicAccountGraphQLQuery} from '../shared/graphql-client'
+
+export default async ({
+  token,
+  deploymentType,
+  sdkConfig,
+}: {
+  token: string
+  deploymentType: string
+  sdkConfig: SDKConfigurationV2
+}): Promise<ZenCtlResponseV2<StepZenCredentialsV2>> => {
+  const url = new URL(sdkConfig.publicAccountApiUrl)
+  // Inlclude the token into the URL so that it is visible in the logs
+  // (allows StepZen to do analytics based on the GCP logs).
+  url.searchParams.set('token', token)
+
+  const {data, errors} = await fetchPublicAccountGraphQLQuery<{
+    account: {
+      account: string
+      adminKey: string
+      serviceKey: string
+    }
+  }>({
+    url,
+    query: `query (
+      $token: String!
+    ) {
+      account: getAccountDetails(
+        token: $token
+      ) {
+        account: accountName
+        adminKey
+        serviceKey: apiKey
+      }
+    }`,
+    variables: {
+      token,
+    },
+    sdkConfig,
+  })
+
+  if (errors) {
+    // strip graphql-specific error details, leave only the message
+    const message = errors.map(error => error.message).join('\n')
+    return {
+      data: undefined,
+      error: {message},
+    }
+  }
+
+  return {data: {...data.account, deploymentType}, error: undefined}
+}

package/src/commands-v2/list.ts

@@ -0,0 +1,98 @@
+// Copyright (c) 2020,2021,2022, StepZen, Inc.
+
+import {
+  SDKConfigurationV2,
+  StepZenEndpointV2,
+  ZenCtlResponseV2,
+} from '../shared/types'
+import {fetchZenCtlGraphQLQuery} from '../shared/graphql-client'
+
+export default async ({
+  account,
+  deploymentType,
+  adminKey,
+  sdkConfig,
+}: {
+  account: string
+  deploymentType: string
+  adminKey: string
+  sdkConfig: SDKConfigurationV2
+}): Promise<ZenCtlResponseV2<StepZenEndpointV2[]>> => {
+  const {data, errors} = await fetchZenCtlGraphQLQuery<{
+    endpoints: Array<{
+      endpointName: string
+      folderName: string
+    }>
+  }>({
+    query: `query (
+      $account: String!
+      $deploymentType: String!
+      $adminKey: String!
+    ) {
+      endpoints: endpointsForAccount(
+        account: $account
+        deploymentType: $deploymentType
+        adminkey: $adminKey
+      ) {
+        endpointName: endpoint_name
+        folderName: folder_name
+      }
+    }`,
+    variables: {
+      account,
+      deploymentType,
+      adminKey,
+    },
+    sdkConfig,
+  })
+
+  if (errors) {
+    // strip graphql-specific error details, leave only the message
+    const message = errors
+      .map(({message}) => {
+        let newMessage = message
+        if (
+          message.startsWith(
+            'ERROR: invalid input value for enum zenctl.deployment_type',
+          )
+        ) {
+          newMessage =
+            `Invalid deployment type: ${deploymentType}.` +
+            ` Please check the 'deploymentType' parameter.`
+        }
+
+        return {
+          message: newMessage,
+        }
+      })
+      .join('\n')
+
+    return {
+      data: undefined,
+      error: {
+        message,
+      },
+    }
+  }
+
+  const endpoints = data.endpoints.filter(Boolean)
+  if (!endpoints.length) {
+    return {
+      data: undefined,
+      error: {
+        message: 'Invalid credentials',
+      },
+    }
+  }
+
+  return {
+    data: endpoints.map(endpoint => ({
+      ...endpoint,
+      public: false, // TODO: implement
+      endpointType: 'dev', // TODO: implement
+      account,
+      deploymentType,
+    })),
+    error: undefined,
+  }
+}

package/src/index.ts

@@ -1,45 +1,10 @@
 // Copyright (c) 2020,2021,2022, StepZen, Inc.
 
 import * as path from 'path'
-import authenticate from './commands/authenticate'
-import {createSdkClient} from './client'
-import {
-  AnonymousClientOptions,
-  SDKConfiguration,
-  UserCredentialsClientOptions,
-} from './shared/types'
+import {init, SDK} from './init'
 
-export const init = (sdkConfig: SDKConfiguration) => {
-  const defaults = {
-    domain: process.env.STEPZEN_DOMAIN || 'stepzen.io',
-    server: process.env.STEPZEN_SERVER_URL || 'https://{account}.stepzen.io',
-  }
-
-  return {
-    verify: (account: string, adminkey: string) => {
-      return authenticate(
-        {
-          account,
-          adminkey,
-          server: defaults.server.replace('{account}', account),
-          domain: defaults.domain,
-        },
-        sdkConfig,
-      )
-    },
-    client: async (
-      options: UserCredentialsClientOptions | AnonymousClientOptions,
-    ) => {
-      return createSdkClient({...defaults, ...options}, sdkConfig)
-    },
-  }
-}
-
-// a helper type to unwrap Promise<U> into U
-type PromisedType<T> = T extends Promise<infer U> ? U : T
-
-export type SDK = ReturnType<typeof init>
-export type SDKClient = PromisedType<ReturnType<SDK['client']>>
+export * from './init'
+export * from './init-v2'
 
 /**
  * The default SDK instance that does not know the name of the app using the SDK.

package/src/init-v2.ts

@@ -0,0 +1,70 @@
+// Copyright (c) 2020,2021,2022, StepZen, Inc.
+
+import accountCommand from './commands-v2/account'
+import {createSdkClient} from './client-v2'
+import {SDKConfigurationV2} from './shared/types'
+
+export const initV2 = (config: {
+  appName: string
+  zenctlApiUrl?: string
+  publicAccountApiUrl?: string
+}) => {
+  const defaults = {
+    zenctlApiUrl:
+      process.env.STEPZEN_ZENCTL_API_URL ||
+      'https://braselton.stepzen.net/api/zenctl2/__graphql',
+    publicAccountApiUrl:
+      process.env.STEPZEN_PUBLIC_ACCOUNT_API_URL ||
+      'https://stepzen.stepzen.net/api/publicaccount/__graphql',
+    deploymentType:
+      process.env.STEPZEN_DEPLOYMENT_TYPE ||
+      process.env.STEPZEN_DOMAIN?.replace('.io', '') ||
+      'steprz',
+  }
+
+  const sdkConfig: SDKConfigurationV2 = {
+    apiVersion: 'v2',
+    zenctlApiUrl: defaults.zenctlApiUrl,
+    publicAccountApiUrl: defaults.publicAccountApiUrl,
+    ...config,
+  }
+
+  return {
+    verify: async (
+      account: string,
+      adminkey: string,
+      deploymentType: string = defaults.deploymentType,
+    ) => {
+      try {
+        const {data} = await accountCommand({
+          account,
+          adminKey: adminkey,
+          deploymentType,
+          sdkConfig,
+        })
+        return Boolean(data?.length)
+      } catch {
+        return false
+      }
+    },
+    client: async (
+      auth:
+        | {account: string; adminKey: string; deploymentType?: string}
+        | {publicAccountToken: string; deploymentType?: string},
+    ) => {
+      return createSdkClient(
+        {
+          deploymentType: defaults.deploymentType,
+          ...auth,
+        },
+        sdkConfig,
+      )
+    },
+  }
+}
+
+// a helper type to unwrap Promise<U> into U
+type PromisedType<T> = T extends Promise<infer U> ? U : T
+
+export type SDKV2 = ReturnType<typeof initV2>
+export type SDKClientV2 = PromisedType<ReturnType<SDKV2['client']>>

package/src/init.ts

@@ -0,0 +1,41 @@
+// Copyright (c) 2020,2021,2022, StepZen, Inc.
+
+import authenticate from './commands/authenticate'
+import {createSdkClient} from './client'
+import {
+  AnonymousClientOptions,
+  SDKConfiguration,
+  UserCredentialsClientOptions,
+} from './shared/types'
+
+export const init = (sdkConfig: SDKConfiguration) => {
+  const defaults = {
+    domain: process.env.STEPZEN_DOMAIN || 'stepzen.io',
+    server: process.env.STEPZEN_SERVER_URL || 'https://{account}.stepzen.io',
+  }
+
+  return {
+    verify: (account: string, adminkey: string) => {
+      return authenticate(
+        {
+          account,
+          adminkey,
+          server: defaults.server.replace('{account}', account),
+          domain: defaults.domain,
+        },
+        sdkConfig,
+      )
+    },
+    client: async (
+      options: UserCredentialsClientOptions | AnonymousClientOptions,
+    ) => {
+      return createSdkClient({...defaults, ...options}, sdkConfig)
+    },
+  }
+}
+
+// a helper type to unwrap Promise<U> into U
+type PromisedType<T> = T extends Promise<infer U> ? U : T
+
+export type SDK = ReturnType<typeof init>
+export type SDKClient = PromisedType<ReturnType<SDK['client']>>