How SailPoint uses Anthropic’s Claude on Amazon Bedrock to automatically generate TypeScript code for SaaS connectors

// imports
import { Context, Response, StdAccountListHandler, StdAccountListOutput } from '@sailpoint/connector-sdk';

const listUsers: StdAccountListHandler = async (context: Context, input: undefined, res: Response) => {
    // retrieve api key and host url from context
    let apiKey = context.apiKey;
    let hostUrl = context.hostUrl;
    let hasMore = true;
    
    // url construction
    let url = `https://${hostUrl}/Management/v2/organizations/${context.organizationId}/users`;
    
    // loop through pages
    while (hasMore) {
        // fetch response from the endpoint
        let response = await fetch(url, {
          headers: {
            'Authorization': `Bearer ${apiKey}`
          }
        });
        let results = await response.json();
  
        // processing users from response
        let users = results.users;
        for (const user of users) {
            const output: StdAccountListOutput = {
                identity: user.id,
                attributes: {
                    user_name: user.user_name,
                    first_name: user.first_name,
                    last_name: user.last_name,
                    user_status: user.user_status, 
                    membership_status: user.membership_status, 
                    email: user.email,
                    created_on: user.created_on, 
                    membership_created_on: user.membership_created_on,                     
                    ds_group_id: user.company_groups.map(group => group.ds_group_id),
                    ds_group_account_id: user.company_groups.map(group => group.ds_group_account_id)                   
                }
            };
        }
        // pagination
        if (results.paging.next) {
          url = results.paging.next;
        } else {
          hasMore = false;
        }
    }
}

"""
You are an expert web developer who has an excellent understanding of REST APIs and backend
API development using TypeScript. Your goal is to understand API specification provided in 
OpenAPI specification or Swagger specification as YAML files and to write TypeScript code,
XML, API descriptions etc. as requested in the task description. Do not deviate from the 
provided specification and documentation and if something is unclear in the specification then 
mention your uncertainty in the comments do not make up information that is not available in 
the specs or description.

When writing TypeScript code, provide minimal but meaningful comments.
"""

"""
You are given an API spec of OpenAPI or Swagger for a REST API endpoint
that serves a list of users for Software as a Service (SaaS) application. You will 
be asked to extract the structure of the User in the JSON response from the API endpoint. 

Here is the API spec provided between the XML tags  . 
Understand and remember the API spec well.


{api_spec}


Use the following instructions to create TypeScript interfaces based on the structure 
of the User. 

- Provide the code in between   XML tags. 
- If there are any nested objects, expand them into their own interfaces.
- Be comprehensive and include all attributes.
- Retrieve all attributes, including those marked as not mandatory, not required, or nullable.
- The attributes are listed under `properties` section.
- Output only one User interface that includes all the attributes from any interfaces it extends.


The expected format of the output is as follows: 
 
// User
interface User {{
  id: number;
  first_name: string;
  last_name: string;
  email: string;
  is_active: boolean;
  company_groups_ids: number[];
  other_attribute: string;
  nested_type: NestedType[];
}}

// Some complex type
interface NestedType {{
    type_id: string;
    some_string_attribute: string;
    some_number_attribute: number;
}}


"""

// User
interface User {
    id: string; // format: uuid
    user_name: string;
    first_name: string;
    last_name: string;
    user_status: string; // One of: 'active' | 'created' | 'closed'
    membership_status: string; // One of: 'activation_required' | 'activation_sent' | 'active' | 'closed' | 'disabled'
    email: string;
    created_on: string; // format: date-time
    membership_created_on: string; // format: date-time
    ds_groups: DsGroup[];
}
  
// DsGroup
interface DsGroup {
    ds_group_id: string; // format: uuid
    account_id: string; // format: uuid
    source_product_name: string;
    group_id: string;
    group_name: string;
    description: string;
    is_admin: boolean;
    last_modified_on: string; // format: date-time
    user_count: number; // format: int32
    external_account_id: number; // format: int64
    account_name: string;
    membership_id: string; // format: uuid
}

"""
Understand and remember the following data model provided 
as a set of TypeScript class definitions.
You will be required to generate a TypeScript function based on the 
data model provided between   XML tags.


{data_model}


DO NOT use the TypeScript interfaces defined above in the code you write, 
as they will be unavailable. Substitute them with the type `any` where required 
to write code that works with strict TypeScript.

Given the TypeScript class definitions and data model above, your goals is to
write a TypeScript function that transforms the user into an object containing two
keys - an `identity` and `attributes`. The attributes is a list of attributes
other than the identifier attribute.

Here are the rules for mapping attributes from the user object to attributes field:


- The function takes in a user and return StdAccountListOutput.
- Extract all attributes specified in the user schema above in the 
- attributes can only contain either primitives values or array of primitive values.
- Determine the type of the attribute from the  above. Do not guess it from the
names of the attributes. E.g. if the name is plural don't assume it is an array.
- All primitive attributes such as string and numbers are copied without transformation.
- All arrays of primitive attributes are copied without transformation.
- All objects are flattened out and their attributes are copied as simple attributes.
- All arrays of objects are converted into multiple attributes where each attribute is an array of primitive type. 
See further instruction below between the XML tags .
- Use `any` type in functions and arrow function definitions so that it works with TypeScript.





Consider the following structure of the response where `obj_array` is an attribute that is array of objects of type `MyObj`.
Then in the flattening process, for the response, you will need to convert the `obj_array` attribute 
into multiple attributes like `obj_array_attribute1`, `obj_array_attribute2` each of which is an array of strings in this case.

interface User {{
  id: string; // format: uuid
  user_name: string;
  first_name: string;
  obj_array: MyObject[];
}}

interface MyObj {{
  attribute1: string; // format: uuid
  attribute2: string; // format: uuid
  attribute3: string;
}}
 


Output the code according to the template program below enclosed between the  XML tags.

This function is part of a larger program so keep the StdAccountListOutput in the function as it is.
Do not overcomplicate and write simple, well readable code. 



function flattenUser(user: any): StdAccountListOutput {{
  return {{
    identity: user.id,
    attributes: {{
      first_name: user.first_name,
      last_name: user.last_name,
      user_type: user.type,
      login: user.login,
      email: user.email,
      location: user.location,
      employee_id: user.employee_id,
      reviewer_id: user.reviewer_id,
      is_active: user.is_active,
      struct_array_attribute: user.struct_array.map( (val: any) => val.struct_attribute)
    }}
  }}
}};


"""

function flattenUser(user: any): StdAccountListOutput {
    const identity = user.id;
    const attributes: { [key: string]: any } = {};
  
    // Copy primitive attributes
    attributes.user_name = user.user_name;
    attributes.first_name = user.first_name;
    attributes.last_name = user.last_name;
    attributes.user_status = user.user_status;
    attributes.membership_status = user.membership_status;
    attributes.email = user.email;
    attributes.created_on = user.created_on;
    attributes.membership_created_on = user.membership_created_on;
  
    // Convert array of objects to multiple attributes
    const dsGroupAttributes: { [key: string]: any[] } = {};
    user.ds_groups.forEach((dsGroup: any) => {
      dsGroupAttributes.ds_group_id = dsGroupAttributes.ds_group_id || [];
      dsGroupAttributes.ds_group_id.push(dsGroup.ds_group_id);
  
      dsGroupAttributes.account_id = dsGroupAttributes.account_id || [];
      dsGroupAttributes.account_id.push(dsGroup.account_id);
  
      dsGroupAttributes.source_product_name = dsGroupAttributes.source_product_name || [];
      dsGroupAttributes.source_product_name.push(dsGroup.source_product_name);
  
      dsGroupAttributes.group_id = dsGroupAttributes.group_id || [];
      dsGroupAttributes.group_id.push(dsGroup.group_id);
  
      dsGroupAttributes.group_name = dsGroupAttributes.group_name || [];
      dsGroupAttributes.group_name.push(dsGroup.group_name);
  
      dsGroupAttributes.description = dsGroupAttributes.description || [];
      dsGroupAttributes.description.push(dsGroup.description);
  
      dsGroupAttributes.is_admin = dsGroupAttributes.is_admin || [];
      dsGroupAttributes.is_admin.push(dsGroup.is_admin);
  
      dsGroupAttributes.last_modified_on = dsGroupAttributes.last_modified_on || [];
      dsGroupAttributes.last_modified_on.push(dsGroup.last_modified_on);
  
      dsGroupAttributes.user_count = dsGroupAttributes.user_count || [];
      dsGroupAttributes.user_count.push(dsGroup.user_count);
  
      dsGroupAttributes.external_account_id = dsGroupAttributes.external_account_id || [];
      dsGroupAttributes.external_account_id.push(dsGroup.external_account_id);
  
      dsGroupAttributes.account_name = dsGroupAttributes.account_name || [];
      dsGroupAttributes.account_name.push(dsGroup.account_name);
  
      dsGroupAttributes.membership_id = dsGroupAttributes.membership_id || [];
      dsGroupAttributes.membership_id.push(dsGroup.membership_id);
    });
  
    Object.assign(attributes, dsGroupAttributes);
  
    return {
      identity,
      attributes
    };
}

"""
Understand and remember the following OpenAPI specification provided between the
  XML tags. You will answer questions based on this specification,
which describes an endpoint for listing users from a SaaS application. 


{api_spec}


In addition to the specification, use the following information about the API to 
understand the details that are not available in the spec. The details
are included in between XML tags  .


{api_info}


The list users API is used to obtain a list of users from the API. This API
may implement one or more pagination schemes to retrieve the list of users. 
Pagination is used to retrieve pages of results one at a time instead of 
all at once.

Your goal is to understand the multiple pagination schemes implemented 
in the API end point and use the simplest scheme to loop over the pages
to retrieve all the users. 

First describe in details how the pagination is implemented by the API 
in a step by step manner. Include the details of how to get the first 
page and then how to get the subsequent pages. Provide the output in between
the XML tags  . If the API does not 
implement pagination then output "No pagination implemented".

If the API implements multiple pagination schemes: 
- Select the easiest scheme and implement using only that one scheme. 
- If the API response contains a next URL either in the response body or the 
headers, prefer that pagination scheme over more complex offset-based schemes.

If there is insufficient or missing information in the specs then do not
make up or guess it. Specify it in the output.

Output the results in the following format


     list all the pagination schemes 
     select one scheme to implement looping 
     steps to get first page 
     steps to get next page 
     condition for exiting loop 
     yes/no 

"""

"""

1. Offset-based pagination using the start and take query parameters. 
2. Index-based pagination using the start and end query parameters. 
3. Link-based pagination using the next and previous links in the response.



Link-based pagination using the next and previous links in the response.



1. Make a GET request to the /v2/organizations/{organizationId}/users endpoint without any pagination parameters. 
2. The response will contain the first page of results and a next link for the next page (if there are more results).



1. Check if the response contains a next link. 
2. If the next link is present, make a GET request to the URL provided in the next link. 
3. The response will contain the next page of results and a next link for the subsequent page (if there are more results).



Continue making requests to the next link until the response no longer contains a next link, indicating that there are no more pages.



yes

"""

"""
Your task is to write a TypeScript program to retrieve a list of users from REST API. Detailed
instructions for the task are provided below. The API typically returns a set of users at a
time, you will have to paginate through the results to retrieve all users while there are more 
results remaining.

Understand and remember the following OpenAPI YAML specification provided between the
  XML tags you will be asked to write a TypeScript program based on it.


{api_spec}


In addition to the specs the following documentation and implementation details about the
API are provided in between the XML tags  .


{api_info}


The following pagination logic specified in between   XML 
tags provides high level details on  how to implement looping over paginated results to retrieve 
all the users. Select the pagination according to the preference mentions in the pagination logic below.


{pagination_logic}



Now, implement a TypeScript function that retrieves all the users following the instructions below

- Do not modify the `flattenUser` function and reproduce it as it is.
- Change only the BODY of `listUsers` function but do not modify the function signature as it is
part of the large program that expects this function signature.
- Do not create or invent any new types.
- For pagination adhere to the instructions provided in  and 
- If pagination requires number of results, then fetch 50 users at a time.
- Assume that `context.hostUrl` from the input context will provide the API hostname and port in the 
format "hostname:port_number" or "host_ip_address:port_number".
- If the API uses a Link based pagination then you typically do not need to reconstruct the url using
`hostUrl` as the complete link will be provided in the next url or in the link headers.
- replace the `endpoint_url` with the endpoint url provided in the specs.
- You can assume that any required values such as `apiKey` will be provided in the `context` variable.
- Change the authorization headers to match the information in the headers.
- Assume that any parameters that are required to construct the path are supplied through `context` variable. The names of such variable 
will match exactly with the variable specified in the templated path in the API specs.


Here is the example output


import {{ Context, Response, StdAccountListHandler, StdAccountListOutput }} from '@sailpoint/connector-sdk';

{flatten_user_function}

const listUsers: StdAccountListHandler = async (context: Context, input: undefined, res: Response) => {{
    let apiKey = context.apiKey;
    let hostUrl = context.hostUrl;
    let hasMore = true;

    let url = 'http://${{hostUrl}}/{{endpoint_path}}';
    while (hasMore) {{

        // fetch response from the endpoint
        let response = await fetch(url, {{
          headers: {{
            'Authorization': `${{apiKey}}`
          }}
        }});
        let results = await response.json();

        // get the users from the returned results
        let users = results.users;
        for (let user of users) {{
            flattened_user = flattenUser(user)
            res.send(flattened_user);
        }}

        // Set the url to the "next" URL from the response if it is available
        if (results.next) {{
          url = results.next;
        }} else {{
          hasMore = false;
        }}
    }}
}}


Output the generated code between the XML tags   and 
only output the code without any additional formatting like triple quotes.
"""

const listAccounts: StdAccountListHandler = async (context: Context, input: undefined, res: Response) => {
    let apiKey = context.apiKey;
    let hostUrl = context.hostUrl;
    let organizationId = context.organizationId;
    let hasMore = true;

    let url = `https://${hostUrl}/Management/v2/organizations/${organizationId}/users`;
    while (hasMore) {

        // fetch response from the endpoint
        let response = await fetch(url, {
          headers: {
            'Authorization': `Bearer ${apiKey}`
          }
        });
        let results = await response.json();

        // get the users from the returned results
        let users = results.users;
        for (let user of users) {
            let flattened_user = flattenUser(user)
            res.send(flattened_user);
        }

        // Set the url to the "next" URL from the response if it is available
        if (results.paging.next) {
          url = results.paging.next;
        } else {
          hasMore = false;
        }
    }
}

Copyright (c) 2017- DocuSign, Inc. (https://www.docusign.com)
swagger: '2.0'
info:
  title: DocuSign API
  version: v2.1
host: api.docusign.net
basePath: "/Management"
schemes:
- https
consumes:
- application/json
produces:
- application/json
paths:
  "/v2/organizations/{organizationId}/users":
    get:
      tags:
      - Users
      summary: Returns information about the users in an organization.
      description: |-
        Returns information about the users in an organization.

        You must include at least one of the following query parameters in the request:

        - `account_id`: The ID of an account associated with the organization.
        - `organization_reserved_domain_id`: The ID of one of the organization's reserved domains.
        - `email`: An email address associated with the users that you want to return.
      operationId: OrganizationUser_OrganizationUsers_GetV2
      produces:
      - application/json
      parameters:
      - name: organizationId
        in: path
        description: The organization ID Guid
        required: true
        type: string
        format: uuid
      - name: start
        in: query
        description: Index of first item to include in the response. The default value
          is 0.
        required: false
        type: integer
        format: int32
      - name: take
        in: query
        description: Page size of the response. The default value is 20.
        required: false
        type: integer
        format: int32
      - name: end
        in: query
        description: Index of the last item to include in the response. Ignored if
          `take` parameter is specified.
        required: false
        type: integer
        format: int32
      - name: email
        in: query
        description: Email address of the desired user. At least one of `email`, `account_id`
          or `organization_reserved_domain_id` must be specified.
        required: false
        type: string
      - name: email_user_name_like
        in: query
        description: Selects users by pattern matching on the user's email address
        required: false
        type: string
      - name: status
        in: query
        description: Status.
        required: false
        type: string
      - name: membership_status
        in: query
        description: |
          The user's membership status. One of:

          - `activation_required`
          - `activation_sent`
          - `active`
          - `closed`
          - `disabled`
        required: false
        type: string
      - name: account_id
        in: query
        description: Select users that are members of the specified account. At least
          one of `email`, `account_id` or `organization_reserved_domain_id` must be
          specified.
        required: false
        type: string
        format: uuid
      - name: organization_reserved_domain_id
        in: query
        description: Select users that are in the specified domain. At least one of
          `email`, `account_id` or `organization_reserved_domain_id` must be specified.
        required: false
        type: string
        format: uuid
      - name: last_modified_since
        in: query
        description: Select users whose data have been modified since the date specified.
          `account_id` or `organization_reserved_domain_id` must be specified.
        required: false
        type: string
      responses:
        '200':
          description: OK
          schema:
            type: object
            properties:
              users:
                type: array
                items:
                  type: object
                  properties:
                    id:
                      format: uuid
                      type: string
                      example: 00000000-0000-0000-0000-000000000000
                      description: The user's unique ID.
                    user_name:
                      type: string
                      description: The full name of the user.
                    first_name:
                      type: string
                      description: The user's first name.
                    last_name:
                      type: string
                      description: The user's last name.
                    user_status:
                      type: string
                      description: |
                        The user's status. One of:

                        - `active`
                        - `created`
                        - `closed`
                    membership_status:
                      type: string
                      description: |
                        The user's membership status. One of:

                        - `activation_required`
                        - `activation_sent`
                        - `active`
                        - `closed`
                        - `disabled`
                    email:
                      type: string
                      description: The email address.
                    created_on:
                      format: date-time
                      type: string
                      description: The date the user's account was created.
                    membership_created_on:
                      format: date-time
                      type: string
                      description: The date on which the user became a member of the organization.
                    ds_groups:
                      type: array
                      items:
                        type: object
                        properties:
                          ds_group_id:
                            format: uuid
                            type: string
                            example: 00000000-0000-0000-0000-000000000000
                            description: ''
                          account_id:
                            format: uuid
                            type: string
                            example: 00000000-0000-0000-0000-000000000000
                            description: Select users that are members of the specified account. At least
                              one of `email`, `account_id` or `organization_reserved_domain_id` must be
                              specified.
                          source_product_name:
                            type: string
                          group_id:
                            type: string
                          group_name:
                            type: string
                          description:
                            type: string
                          is_admin:
                            type: boolean
                          last_modified_on:
                            format: date-time
                            type: string
                          user_count:
                            format: int32
                            type: integer
                          external_account_id:
                            format: int64
                            type: integer
                          account_name:
                            type: string
                          membership_id:
                            format: uuid
                            type: string
                            example: 00000000-0000-0000-0000-000000000000
                  description: Information about a user.
                description: A list of users.
              paging:
                  type: object
                  properties:
                    result_set_size:
                      format: int32
                      type: integer
                      description: The number of items in a result set (page).
                    result_set_start_position:
                      format: int32
                      type: integer
                      description: The index position of the first result in this set.
                    result_set_end_position:
                      format: int32
                      type: integer
                      description: The index position of the last result in this set.
                    total_set_size:
                      format: int32
                      type: integer
                      description: The total number of results.
                    next:
                      type: string
                      description: 'A URL to the next set of results. '
                    previous:
                      type: string
                      description: 'A URL to the previous set of results. '
                  description: Contains information about paging through the results.
            description: A response containing information about users.