How SailPoint makes use of Anthropic’s Claude on Amazon Bedrock to routinely generate TypeScript code for SaaS connectors

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

const listUsers: StdAccountListHandler = async (context: Context, enter: undefined, res: Response<StdAccountListOutput>) => {
    // retrieve api key and host url from context
    let apiKey = context.apiKey;
    let hostUrl = context.hostUrl;
    let hasMore = true;
    
    // url building
    let url = `https://${hostUrl}/Administration/v2/organizations/${context.organizationId}/customers`;
    
    // loop via pages
    whereas (hasMore) {
        // fetch response from the endpoint
        let response = await fetch(url, {
          headers: {
            'Authorization': `Bearer ${apiKey}`
          }
        });
        let outcomes = await response.json();
  
        // processing customers from response
        let customers = outcomes.customers;
        for (const person of customers) {
            const output: StdAccountListOutput = {
                id: person.id,
                attributes: {
                    user_name: person.user_name,
                    first_name: person.first_name,
                    last_name: person.last_name,
                    user_status: person.user_status, 
                    membership_status: person.membership_status, 
                    electronic mail: person.electronic mail,
                    created_on: person.created_on, 
                    membership_created_on: person.membership_created_on,                     
                    ds_group_id: person.company_groups.map(group => group.ds_group_id),
                    ds_group_account_id: person.company_groups.map(group => group.ds_group_account_id)                   
                }
            };
        }
        // pagination
        if (outcomes.paging.subsequent) {
          url = outcomes.paging.subsequent;
        } else {
          hasMore = false;
        }
    }
}

"""
You're an skilled net developer who has a wonderful understanding of REST APIs and backend
API growth utilizing TypeScript. Your aim is to know API specification supplied in 
OpenAPI specification or Swagger specification as YAML information and to jot down TypeScript code,
XML, API descriptions and many others. as requested within the activity description. Don't deviate from the 
supplied specification and documentation and if one thing is unclear within the specification then 
point out your uncertainty within the feedback don't make up info that isn't out there in 
the specs or description.

When writing TypeScript code, present minimal however significant feedback.
"""

"""
You're given an API spec of OpenAPI or Swagger for a REST API endpoint
that serves a listing of customers for Software program as a Service (SaaS) software. You'll 
be requested to extract the construction of the Person within the JSON response from the API endpoint. 

Right here is the API spec supplied between the XML tags <api-spec> </api-spec>. 
Perceive and bear in mind the API spec nicely.

<api-spec>
{api_spec}
</api-spec>

Use the next directions to create TypeScript interfaces primarily based on the construction 
of the Person. 
<directions>
- Present the code in between <data-model> </data-model> XML tags. 
- If there are any nested objects, broaden them into their very own interfaces.
- Be complete and embrace all attributes.
- Retrieve all attributes, together with these marked as not obligatory, not required, or nullable.
- The attributes are listed below `properties` part.
- Output just one Person interface that features all of the attributes from any interfaces it extends.
</directions>

The anticipated format of the output is as follows: 
<data-model> 
// Person
interface Person {{
  id: quantity;
  first_name: string;
  last_name: string;
  electronic mail: string;
  is_active: boolean;
  company_groups_ids: quantity[];
  other_attribute: string;
  nested_type: NestedType[];
}}

// Some complicated sort
interface NestedType {{
    type_id: string;
    some_string_attribute: string;
    some_number_attribute: quantity;
}}

</data-model>
"""

// Person
interface Person  'created' 
  
// 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: quantity; // format: int32
    external_account_id: quantity; // format: int64
    account_name: string;
    membership_id: string; // format: uuid
}

"""
Perceive and bear in mind the next information mannequin supplied 
as a set of TypeScript class definitions.
You can be required to generate a TypeScript perform primarily based on the 
information mannequin supplied between <data-model> </data-model> XML tags.

<data-model>
{data_model}
</data-model>

DO NOT use the TypeScript interfaces outlined above within the code you write, 
as they are going to be unavailable. Substitute them with the sort `any` the place required 
to jot down code that works with strict TypeScript.

Given the TypeScript class definitions and information mannequin above, your objectives is to
write a TypeScript perform that transforms the person into an object containing two
keys - an `id` and `attributes`. The attributes is a listing of attributes
apart from the identifier attribute.

Listed below are the foundations for mapping attributes from the person object to attributes discipline:

<instructions-for-mapping>
- The perform takes in a person and return StdAccountListOutput.
- Extract all attributes specified within the person schema above within the <data-model>
- attributes can solely comprise both primitives values or array of primitive values.
- Decide the kind of the attribute from the <data-model> above. Don't guess it from the
names of the attributes. E.g. if the identify is plural do not assume it's an array.
- All primitive attributes resembling string and numbers are copied with out transformation.
- All arrays of primitive attributes are copied with out transformation.
- All objects are flattened out and their attributes are copied as easy attributes.
- All arrays of objects are transformed into a number of attributes the place every attribute is an array of primitive sort. 
See additional instruction under between the XML tags <object-array-instructions>.
- Use `any` sort in features and arrow perform definitions in order that it really works with TypeScript.
</instructions-for-mapping>


<object-array-instructions>

Take into account the next construction of the response the place `obj_array` is an attribute that's array of objects of sort `MyObj`.
Then within the flattening course of, for the response, you will have to transform the `obj_array` attribute 
into a number of attributes like `obj_array_attribute1`, `obj_array_attribute2` every of which is an array of strings on this case.

interface Person {{
  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;
}}
 </object-array-instructions>


Output the code based on the template program under enclosed between the <user-mapping-function> XML tags.

This perform is a component of a bigger program so preserve the StdAccountListOutput within the perform as it's.
Don't overcomplicate and write easy, nicely readable code. 

<user-mapping-function>

perform flattenUser(person: any): StdAccountListOutput {{
  return {{
    id: person.id,
    attributes: {{
      first_name: person.first_name,
      last_name: person.last_name,
      user_type: person.sort,
      login: person.login,
      electronic mail: person.electronic mail,
      location: person.location,
      employee_id: person.employee_id,
      reviewer_id: person.reviewer_id,
      is_active: person.is_active,
      struct_array_attribute: person.struct_array.map( (val: any) => val.struct_attribute)
    }}
  }}
}};

</user-mapping-function>
"""

perform flattenUser(person: any): StdAccountListOutput {
    const id = person.id;
    const attributes: { [key: string]: any } = {};
  
    // Copy primitive attributes
    attributes.user_name = person.user_name;
    attributes.first_name = person.first_name;
    attributes.last_name = person.last_name;
    attributes.user_status = person.user_status;
    attributes.membership_status = person.membership_status;
    attributes.electronic mail = person.electronic mail;
    attributes.created_on = person.created_on;
    attributes.membership_created_on = person.membership_created_on;
  
    // Convert array of objects to a number of attributes
    const dsGroupAttributes: { [key: string]: any[] } = {};
    person.ds_groups.forEach((dsGroup: any) => );
  
    Object.assign(attributes, dsGroupAttributes);
  
    return {
      id,
      attributes
    };
}

"""
Perceive and bear in mind the next OpenAPI specification supplied between the
<api-spec> </api-spec> XML tags. You'll reply questions primarily based on this specification,
which describes an endpoint for itemizing customers from a SaaS software. 

<api-spec>
{api_spec}
</api-spec>

Along with the specification, use the next details about the API to 
perceive the small print that aren't out there within the spec. The main points
are included in between XML tags <api-info> </api-info>.

<api-info>
{api_info}
</api_info>

The checklist customers API is used to acquire a listing of customers from the API. This API
could implement a number of pagination schemes to retrieve the checklist of customers. 
Pagination is used to retrieve pages of outcomes one after the other as a substitute of 
suddenly.

Your aim is to know the a number of pagination schemes applied 
within the API finish level and use the only scheme to loop over the pages
to retrieve all of the customers. 

First describe in particulars how the pagination is applied by the API 
in a step-by-step method. Embody the small print of learn how to get the primary 
web page after which learn how to get the next pages. Present the output in between
the XML tags <pagination-logic> </pagination-logic>. If the API doesn't 
implement pagination then output "No pagination applied".

If the API implements a number of pagination schemes: 
- Choose the best scheme and implement utilizing solely that one scheme. 
- If the API response comprises a subsequent URL both within the response physique or the 
headers, choose that pagination scheme over extra complicated offset-based schemes.

If there's inadequate or lacking info within the specs then don't
make up or guess it. Specify it within the output.

Output the ends in the next format

<pagination-logic>
    <pagination-schemes> checklist all of the pagination schemes <pagination-schemes>
    <selected-scheme> choose one scheme to implement looping </selected-scheme>
    <steps-first-page> steps to get first web page </steps-first-page>
    <steps-next> steps to get subsequent web page </steps-next>
    <termination-logic> situation for exiting loop </termination-logic>
    <information-complete> sure/no </information-complete>
</pagination-logic>
"""

"""
<pagination-schemes>
1. Offset-based pagination utilizing the beginning and take question parameters. 
2. Index-based pagination utilizing the beginning and finish question parameters. 
3. Hyperlink-based pagination utilizing the subsequent and former hyperlinks within the response.
</pagination-schemes>

<selected-scheme>
Hyperlink-based pagination utilizing the subsequent and former hyperlinks within the response.
</selected-scheme>

<steps-first-page>
1. Make a GET request to the /v2/organizations/{organizationId}/customers endpoint with none pagination parameters. 
2. The response will comprise the primary web page of outcomes and a subsequent hyperlink for the subsequent web page (if there are extra outcomes).
</steps-first-page>

<steps-next>
1. Examine if the response comprises a subsequent hyperlink. 
2. If the subsequent hyperlink is current, make a GET request to the URL supplied within the subsequent hyperlink. 
3. The response will comprise the subsequent web page of outcomes and a subsequent hyperlink for the next web page (if there are extra outcomes).
</steps-next>

<termination-logic>
Proceed making requests to the subsequent hyperlink till the response now not comprises a subsequent hyperlink, indicating that there aren't any extra pages.
</termination-logic>

<information-complete>
sure
</information-complete>
"""

"""
Your activity is to jot down a TypeScript program to retrieve a listing of customers from REST API. Detailed
directions for the duty are supplied under. The API usually returns a set of customers at a
time, you'll have to paginate via the outcomes to retrieve all customers whereas there are extra 
outcomes remaining.

Perceive and bear in mind the next OpenAPI YAML specification supplied between the
<api-spec> </api-spec> XML tags you may be requested to jot down a TypeScript program primarily based on it.

<api-spec>
{api_spec}
</api-spec>

Along with the specs the next documentation and implementation particulars concerning the
API are supplied in between the XML tags <api-info> </api-info>.

<api-info>
{api_info}
</api_info>

The next pagination logic laid out in between <pagination-logic> </pagination-logic> XML 
tags gives excessive degree particulars on  learn how to implement looping over paginated outcomes to retrieve 
all of the customers. Choose the pagination based on the desire mentions within the pagination logic under.

<pagination-logic>
{pagination_logic}
</pagination-logic>


Now, implement a TypeScript perform that retrieves all of the customers following the directions under
<directions>
- Don't modify the `flattenUser` perform and reproduce it as it's.
- Change solely the BODY of `listUsers` perform however don't modify the perform signature as it's
a part of the massive program that expects this perform signature.
- Don't create or invent any new varieties.
- For pagination adhere to the directions supplied in <pagination-logic> and <api-spec>
- If pagination requires variety of outcomes, then fetch 50 customers at a time.
- Assume that `context.hostUrl` from the enter context will present the API hostname and port within the 
format "hostname:port_number" or "host_ip_address:port_number".
- If the API makes use of a Hyperlink primarily based pagination you then usually don't must reconstruct the url utilizing
`hostUrl` as the whole hyperlink shall be supplied within the subsequent url or within the hyperlink headers.
- substitute the `endpoint_url` with the endpoint url supplied within the specs.
- You possibly can assume that any required values resembling `apiKey` shall be supplied within the `context` variable.
- Change the authorization headers to match the data within the headers.
- Assume that any parameters which can be required to assemble the trail are equipped via `context` variable. The names of such variable 
will match precisely with the variable specified within the templated path within the API specs.
</directions>

Right here is the instance output

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

{flatten_user_function}

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

    let url="http://${{hostUrl}}/{{endpoint_path}}";
    whereas (hasMore) {{

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

        // get the customers from the returned outcomes
        let customers = outcomes.customers;
        for (let person of customers) {{
            flattened_user = flattenUser(person)
            res.ship(flattened_user);
        }}

        // Set the url to the "subsequent" URL from the response whether it is out there
        if (outcomes.subsequent) {{
          url = outcomes.subsequent;
        }} else {{
          hasMore = false;
        }}
    }}
}}
</example-template>

Output the generated code between the XML tags <list-users-code> </list-users-code> and 
solely output the code with none extra formatting like triple quotes.
"""

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

    let url = `https://${hostUrl}/Administration/v2/organizations/${organizationId}/customers`;
    whereas (hasMore) {

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

        // get the customers from the returned outcomes
        let customers = outcomes.customers;
        for (let person of customers) {
            let flattened_user = flattenUser(person)
            res.ship(flattened_user);
        }

        // Set the url to the "subsequent" URL from the response whether it is out there
        if (outcomes.paging.subsequent) {
          url = outcomes.paging.subsequent;
        } else {
          hasMore = false;
        }
    }
}

Copyright (c) 2017- DocuSign, Inc. (https://www.docusign.com)
swagger: '2.0'
information:
  title: DocuSign API
  model: v2.1
host: api.docusign.internet
basePath: "/Administration"
schemes:
- https
consumes:
- software/json
produces:
- software/json
paths:
  "/v2/organizations/{organizationId}/customers":
    get:
      tags:
      - Customers
      abstract: Returns details about the customers in a corporation.
      description: |-
        Returns details about the customers in a corporation.

        You need to embrace no less than one of many following question parameters within the request:

        - `account_id`: The ID of an account related to the group.
        - `organization_reserved_domain_id`: The ID of one of many group's reserved domains.
        - `electronic mail`: An electronic mail tackle related to the customers that you simply need to return.
      operationId: OrganizationUser_OrganizationUsers_GetV2
      produces:
      - software/json
      parameters:
      - identify: organizationId
        in: path
        description: The group ID Guid
        required: true
        sort: string
        format: uuid
      - identify: begin
        in: question
        description: Index of first merchandise to incorporate within the response. The default worth
          is 0.
        required: false
        sort: integer
        format: int32
      - identify: take
        in: question
        description: Web page dimension of the response. The default worth is 20.
        required: false
        sort: integer
        format: int32
      - identify: finish
        in: question
        description: Index of the final merchandise to incorporate within the response. Ignored if
          `take` parameter is specified.
        required: false
        sort: integer
        format: int32
      - identify: electronic mail
        in: question
        description: E mail tackle of the specified person. A minimum of certainly one of `electronic mail`, `account_id`
          or `organization_reserved_domain_id` have to be specified.
        required: false
        sort: string
      - identify: email_user_name_like
        in: question
        description: Selects customers by sample matching on the person's electronic mail tackle
        required: false
        sort: string
      - identify: standing
        in: question
        description: Standing.
        required: false
        sort: string
      - identify: membership_status
        in: question
        description: |
          The person's membership standing. One among:

          - `activation_required`
          - `activation_sent`
          - `energetic`
          - `closed`
          - `disabled`
        required: false
        sort: string
      - identify: account_id
        in: question
        description: Choose customers which can be members of the desired account. A minimum of
          certainly one of `electronic mail`, `account_id` or `organization_reserved_domain_id` have to be
          specified.
        required: false
        sort: string
        format: uuid
      - identify: organization_reserved_domain_id
        in: question
        description: Choose customers which can be within the specified area. A minimum of certainly one of
          `electronic mail`, `account_id` or `organization_reserved_domain_id` have to be specified.
        required: false
        sort: string
        format: uuid
      - identify: last_modified_since
        in: question
        description: Choose customers whose information have been modified for the reason that date specified.
          `account_id` or `organization_reserved_domain_id` have to be specified.
        required: false
        sort: string
      responses:
        '200':
          description: OK
          schema:
            sort: object
            properties:
              customers:
                sort: array
                gadgets:
                  sort: object
                  properties:
                    id:
                      format: uuid
                      sort: string
                      instance: 00000000-0000-0000-0000-000000000000
                      description: The person's distinctive ID.
                    user_name:
                      sort: string
                      description: The total identify of the person.
                    first_name:
                      sort: string
                      description: The person's first identify.
                    last_name:
                      sort: string
                      description: The person's final identify.
                    user_status:
                      sort: string
                      description: |
                        The person's standing. One among:

                        - `energetic`
                        - `created`
                        - `closed`
                    membership_status:
                      sort: string
                      description: |
                        The person's membership standing. One among:

                        - `activation_required`
                        - `activation_sent`
                        - `energetic`
                        - `closed`
                        - `disabled`
                    electronic mail:
                      sort: string
                      description: The e-mail tackle.
                    created_on:
                      format: date-time
                      sort: string
                      description: The date the person's account was created.
                    membership_created_on:
                      format: date-time
                      sort: string
                      description: The date on which the person turned a member of the group.
                    ds_groups:
                      sort: array
                      gadgets:
                        sort: object
                        properties:
                          ds_group_id:
                            format: uuid
                            sort: string
                            instance: 00000000-0000-0000-0000-000000000000
                            description: ''
                          account_id:
                            format: uuid
                            sort: string
                            instance: 00000000-0000-0000-0000-000000000000
                            description: Choose customers which can be members of the desired account. A minimum of
                              certainly one of `electronic mail`, `account_id` or `organization_reserved_domain_id` have to be
                              specified.
                          source_product_name:
                            sort: string
                          group_id:
                            sort: string
                          group_name:
                            sort: string
                          description:
                            sort: string
                          is_admin:
                            sort: boolean
                          last_modified_on:
                            format: date-time
                            sort: string
                          user_count:
                            format: int32
                            sort: integer
                          external_account_id:
                            format: int64
                            sort: integer
                          account_name:
                            sort: string
                          membership_id:
                            format: uuid
                            sort: string
                            instance: 00000000-0000-0000-0000-000000000000
                  description: Details about a person.
                description: A listing of customers.
              paging:
                  sort: object
                  properties:
                    result_set_size:
                      format: int32
                      sort: integer
                      description: The variety of gadgets in a consequence set (web page).
                    result_set_start_position:
                      format: int32
                      sort: integer
                      description: The index place of the primary consequence on this set.
                    result_set_end_position:
                      format: int32
                      sort: integer
                      description: The index place of the final consequence on this set.
                    total_set_size:
                      format: int32
                      sort: integer
                      description: The full variety of outcomes.
                    subsequent:
                      sort: string
                      description: 'A URL to the subsequent set of outcomes. '
                    earlier:
                      sort: string
                      description: 'A URL to the earlier set of outcomes. '
                  description: Incorporates details about paging via the outcomes.
            description: A response containing details about customers.