Page tree

Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

...

com.castsoftware.typescript

What's new

See TypeScript and Frameworks - 1.7 8 - Release Notes for more information.

Description

...

  • TypeScript is an open-source programming  language. It is a superset of JavaScript that adds optional typing and that compiles to plain JavaScript.
  • Angular is a front-end web framework used to create modern web platform capabilities.
  • React and React-Native are frameworks for building user interfaces
  • Node.js is a run-time environment that executes JavaScript code outside of a browser thus allowing to develop the server-side of an application using TypeScript.
    • Express is a server web framework.
    • Fastify is a server web framework.
    • Axios is a promise based HTTP client.
    • Mongoose is a MongoDB object modelling modeling tool designed to work in an asynchronous environment.
    • AWS is a cloud service by Amazon.
    • TypeORM is an Object-Relational Mapping framework.
    • Sequelize is a framework for database management.

...

VersionSupported
1.x

(tick) 

2.x

(tick)

3.x

(tick)

4.x

(tick)

Angular

VersionSupported
2

(tick)

4

(tick)

5

(tick)

6

(tick)

7

(tick)

8(tick)
9(tick)
10(tick)
11(tick)
12(tick)
13(tick)

React

VersionSupported
15.x

(tick)

16.x

(tick)

...

AWSS3

Library

Comment

Data Access

Web Service

Supported versions

ExpressNode.js application framework
(tick)4.x
MongooseMongoDB access(tick)
5.x
SequelizeNode.js application framework(tick)
5.x; 6.x
TypeORMORM(tick)
0.2.x
FastifyNode.js server
(tick)3.x
AxiosPromise based HTTP client
(tick)0.x
Node-mongodb-nativeMongoDB access(tick)
3.x
nestjsNode.js application framework
(tick)6.x; 7.x
httpsNode.js web service
(tick)
fetchJavaScript builtin web service
(tick)
requestHTTP request client 'request'
(tick)2.x

request-promise

HTTP request client 'request'
(tick)4.x
request-promise-nativeHTTP request client 'request'
(tick)1.x
request-promise-anyHTTP request client 'request'
(tick)1.x
Mongo-clientMongoDB access(error)

CouchdbCouchdb access(error)

Node-couchdbCouchdb access(error)

Couchdb-nanoCouchdb access(error)

MarklogicMarklogic access(error)

my_connectionMySQL access(tick)
0.x
pgPostgreSQL access(tick)
7.x; 8.x
oracledbOracle Database access(tick)
4.x; 5.x

node-sqlserver

MsnodeSQL access(tick)
0.x

mssql

MsSQL access(tick) 
5.x; 6.x
HapiNode.js application framework(error)

SailsNode.js application framework(error)(error)
LoopbackNode.js application framework

(error)

(error)
KoaNode.js application framework(error)

KnexNode.js SQL query builder (error)

MemcachedStorage framework(error)

AWS.DynamoDBS3Amazon database accessstorage service(error)(tick)
SDK 2.Amazon storage service(tick)2xx
AWS.LambdaAmazon routing solution
(tick)Cloudformation, Serverless framework, SAM
AWS.SQSAmazon Simple Queue Service
(tick)SDK 2.x

Supported Emailing frameworks: @sendgrid/mail, nodemailer

Files analyzed

Icon(s)FileExtension

TypeScript.ts

TypeScript.tsx

...

Warning
titleSkipped files

The TypeScript analyzer will automatically skip files inside folders (or sub-folders) that by convention pertain to either external libraries or unit-testing. Currently, the following are skipped:

  • Folders named as node_modules, e2e, e2e-bdd, e2e-app
  • Files with following name endings: .spec.ts, -spec.ts, _spec.ts, .d.ts

As mentioned in the introduction, TypeScript is a language that will be compiled to generate JavaScript files. Sometimes, the delivery will include these files, this is why the analyzer will skip the generated JavaScript files if we find their original TypeScript file.

Function Point, Quality, and Sizing support

This extension provides the following support:

...

Info

The latest release status of this extension can be seen when downloading it from the CAST Extend server.

Packaging, delivering, and analyzing your source code

Once the extension is downloaded and installed, you can now package your source code and run an analysis. The process of packaging, delivering and analyzing your source code is described below:

...

Image Removed S3 Region S3 Bucket
IconMetamodel nameCode Reference (example)

Typescript Module


Typescript Namespace


Code Block
languagejs
namespace A {
     
    // not exported
    function a() {
    }
}


Typescript Class


Code Block
languagejs
export class TodoStorage implements ... {


...     
}


Class Initializer


Code Block
languagejs
export class TodoStorage implements ... {

field = new Todo();

...     
}


Typescript Method


Code Block
languagejs
export class TodoStorage implements ... {

	// Standard method
	getTodos(): Observable<Todo[]> {
	}


	// Arrow method
	m1 = () => {alert("m1 is called")}     
}


Typescript Interface


Code Block
languagejs
export interface ITodoScope extends... {


...     
}


Typescript Function


Code Block
languagejs
// Named function
function add(x, y) {
    return x + y;
}

// Anonymous function
function(x, y) { return x + y; };


// Arrow function
var f = (x,y) => { return x + y };


// Anonymous arrow function
(x,y) => x+y;

// Generator function
function* infiniteSequence() {
    var i = 0;
    while(true) {
        yield i++;
    }
}


Angular Component

Angular Directive

Angular GET http service

TypeScript GET http service


Angular POST http service

TypeScript POST http service


Angular PUT http service

TypeScript PUT http service


Angular DELETE http service

TypeScript DELETE http service


HTML5 HTML fragment


ReactJS Application

ReactJS Component

ReactJS Form

Node.js Delete Operation Service
Node.js Get Operation Service
Node.js Post Operation Service
Node.js Put Operation Service

Node.js MongoDB connection

Node.js MongoDB collection

TypeScript SQL query

Node.js AWS SQS Publisher

Node.js AWS SQS Receiver

Node.js AWS SQS Unknown Publisher

Node.js AWS SQS Unknown Receiver

Image Added

Node.js AWS SNS Publisher

Image Added

Node.js Image RemovedAWS SNS Subscriber

Image Added

Node.js Image RemovedAWS SNS Unknown Publisher

Image Added

Node.js AWS Lambda Get Operation ServiceSNS Unknown Subscriber

Node.js AWS Lambda Post Operation Service

Node.js AWS Lambda Put Operation Service

Node.js AWS Lambda Delete Operation Service

Node.js AWS Lambda Any Operation Service

Node.js AWS Lambda Function

Image Added

Node.js Call to Lambda

Image Added

Node.js Call to unknown Lambda

Image Added

Node.js S3 Bucket

Image Added

Node.js S3 Unknown Bucket

More about Typescript analysis 

Expand

Support of arrow functions and methods

Arrow functions which have been introduced in typescript following ES6 standard (also known as ES2015) are supported. Since arrow functions are equivalent to standard functions, the same function objects are created by the analyzer for both standard functions and arrow functions. Arrow functions can also define methods in which case method objects are created by the analyzer. Examples of arrow functions and methods are provided in the Objects section of this documentation.

Support of anonymous functions

For anonymous functions, the analyzer creates function objects named <Anonymous$i> where $i is incremented such that each anonymous function object has a unique fullname.

Web Services

XMLHttpRequest

The analysis of the following code will create a TypeScript GET http service named "foo/url" and a callLink between my_func function and that service :

function my_func(){

  var xhttp = new XMLHttpRequest();
  xhttp.open("GET", "foo/url", false);
  xhttp.send();

}

 Image Modified

fetch

The analysis of the following code will create a TypeScript POST http service named "foo/url" and a callLink between my_func function and that service :

Code Block
function my_func(){
  const response = await fetch('foo/path', {
    method: 'POST'
  })
}

...

Expand

Web Services

Angular web services are supported for both the older Http and new HttpClient (Angular ≥4.3) libraries. The method calls get, post, put, delete, jsonp, and request are recognized.

Window variable

The JavaScript window variable can be used to pass values such as urls. The windows variable is accessible from all modules. So when analyzing the following modules:

Code Block
languagejs
titlemodule1.ts
window.myurl = "foo/url/"


import
Code Block
languagejs
titleexample web services
module2.ts
function my_func(){
HttpClient
}  from '@angular/common/http';

// web-service_GET.ts
 
export class ExampleService {

  constructor(private http: HttpClient) { }
  getData() {
    const url = "http://httpbin.org/get";
    return this.http.get(url);
  }
}

The results of this code snippet are shown below.:

Image Removed

Finally the use of the rxjs/ajax API as web service call is also supported. The different types of web services (GET, POST, PUT, DELELTE) are represented with the same Angular objects we have used above, despite they are not restricted to the Angular framework.

Angular components and HTML fragments

In addition to the basic TypeScript objects the analyzer will generate specific objects and links for the Angular framework. In the following example the analyser creates a TypeScript module object associated to the file and a TypeScript class object associated to the decorated class MyComponentAngular components objects are created when finding special class decorators with name Component. The view of Angular components is described in HTML language and the associated code can be either found in an external .html file or embedded in the decorator metadata. 

Code Block
languagejs
titleLink to html fragments
// example.ts
 
@Component({
  selector: 'click-me',
  template: `
    <button (click)="onClickMe()">Click me!</button>
    {{clickMessage}}`
})
export class MyComponent {
}

For embedded data, the analyzer creates an HTML5 HTML Fragment belonging to the component, and will automatically generate a use (U) link between the Component and the HTML fragment:

Image Removed

The generation of these links is necessary to describe the higher level call flow abstracted in the Angular framework and thus to retrieve transactions.

Environment variables

In our analysis we consider a production deployment scenario. Thus we mimic the behavior of Angular when overloading behind-the-scenes the variables declared inside the exported environment dictionary defined in environment.ts  by those defined in environment.prod.ts. Global variables might be used to connect different technology layers (via URLs for example), thus retrieving them correctly can be critical for full transactions. Latest versions of Angular allows using many different production files. We only support a single production environment file, the standard environment.prod.ts. When using a no-production environment file a warning message will be logged.

Code Block
languagejs
// environment.ts
export const environment = { 
  production: false,
  urls = { .... }   // urls used for development
};
Code Block
languagejs
// environment.prod.ts
export const environment = { 
  production: true,
  urls = { .... }   // production urls
};

Known limitations

  • Connectivity between components through Angular routing is not supported.
  • Use of HttpRequest in Angular is not supported

More about React and React-Native framework analysis

Expand

ReactJS Application

This declaration will create a ReactJS application named App:

Code Block
languagexml
ReactDOM.render(
  <AppContainer>
    <Provider store={store}>
      <App version={appVersion} />
    </Provider>
  </AppContainer>,
  appElement
);

ReactJS Component

This declaration will create a ReactJS component named Sequence because the class inherits from Component (a class which inherits from PureComponent would also induce the creation of a ReactJS component). A component must contain a render method. The render method is automatically called when the component is refered to in an HTML fragment:

Code Block
languagexml
import React, { Component } from 'react';
 
 class Sequence extends Component {
 
  shouldComponentUpdate(nextProps) {
    return this.props.positionFrom !== nextProps.positionFrom ||
      this.props.sequence !== nextProps.sequence ||
      this.props.nucleotidesPerRow !== nextProps.nucleotidesPerRow ||
      this.props.rowHeight !== nextProps.rowHeight;
  }
 
  render() {
    return (
      <g>
        {this.props.sequence.map((nucleotide, index) =>
          <Nucleotide
            type={nucleotide}
            position={this.props.positionFrom + index}
            key={index}
            index={index}
            onClick={this.props.onNucleotideClick}
            {...this.props}
          />,
        )}
      </g>
    );
  }
}

ReactJS Form

This declaration will create a ReactJS form named contact
var xhttp = new XMLHttpRequest();
  xhttp.open("GET", window['myurl'], false);
  xhttp.send();

}

a webservice object is created with the url set through the window variable: 

Image Added

Anchor
MoreAngular
MoreAngular
More about Angular framework analysis

Expand

Web Services

Angular web services are supported for both the older Http and new HttpClient (Angular ≥4.3) libraries. The method calls get, post, put, delete, jsonp, and request are recognized.

Code Block
languagejs
titleexample web services
import { HttpClient } from '@angular/common/http';

// web-service_GET.ts
 
export class ExampleService {

  constructor(private http: HttpClient) { }
  getData() {
    const url = "http://httpbin.org/get";
    return this.http.get(url);
  }
}

The results of this code snippet are shown below.:

Image Added

Finally the use of the rxjs/ajax API as web service call is also supported. The different types of web services (GET, POST, PUT, DELETE) are represented with the same Angular objects we have used above, despite they are not restricted to the Angular framework.

Angular components and HTML fragments

In addition to the basic TypeScript objects the analyzer will generate specific objects and links for the Angular framework. In the following example, the analyzer creates a TypeScript module object associated with the file and a TypeScript class object associated with the decorated class MyComponentAngular components objects are created when finding special class decorators with the name Component. The view of Angular components is described in HTML language and the associated code can be either found in an external .html file or embedded in the decorator metadata. 

Code Block
languagejs
titleLink to html fragments
// example.ts
 
@Component({
  selector: 'click-me',
  template: `
    <button (click)="onClickMe()">Click me!</button>
    {{clickMessage}}`
})
export class MyComponent {
}

For embedded data, the analyzer creates an HTML5 HTML Fragment belonging to the component, and will automatically generate a use (U) link between the Component and the HTML fragment:

Image Added

The generation of these links is necessary to describe the higher level call flow abstracted in the Angular framework and thus to retrieve transactions.

Environment variables

In our analysis, we consider a production deployment scenario. Thus we mimic the behavior of Angular when overloading behind-the-scenes the variables declared inside the exported environment dictionary defined in environment.ts  by those defined in environment.prod.ts. Global variables might be used to connect different technology layers (via URLs for example), thus retrieving them correctly can be critical for full transactions. The latest versions of Angular allow using many different production files. We only support a single production environment file, the standard environment.prod.ts. When using a no-production environment file a warning message will be logged.

Code Block
languagejs
// environment.ts
export const environment = { 
  production: false,
  urls = { .... }   // urls used for development
};


Code Block
languagejs
// environment.prod.ts
export const environment = { 
  production: true,
  urls = { .... }   // production urls
};

Injection with useValue

Dependencies are services or objects that a class needs to perform its function. Dependency injection, or DI, is a design pattern in which a class requests dependencies from external sources rather than creating them. 
The useValue key allows associating a fixed value with a Dependency Injection (DI) token. This is often used to provide runtime configuration constants such as website base addresses.

For instance, in the following, the Angular module provides an "environment" value.

Code Block
languagejs
import {Environment} from 'path/to/environmentinterface';
import { NgModule } from '@angular/core';

const environment: Environment = {
  my_url: "foo/path"
}

@NgModule({
  providers: [
    { provide: Environment, useValue: environment}
  ]
})
export class AppModule { 
}

This value can be accessed by other components through the constructor (note that the Type given to the "env" variable is the same as the one given in the provide key (see previous source code).

Code Block
languagejs
import { HttpClient } from '@angular/common/http';
import { Environment } from 'path/to/environmentinterface';
import { Component } from '@angular/core';


@Component()
export class FooClass{
  constructor (private http: HttpClient, private env : Environment){}

  getData() {
    const url = env.my_url;
    return this.http.get(url);
  }
}

Analyzing the previous modules will create a web service with the URL given through injection:  

Image Added

Known limitations

  • Connectivity between components through Angular routing is not supported.
  • The support of TypeScript Map is limited. See the section Support of TypeScript Map to see which cases are supported.
  • Use of HttpRequest in Angular is not supported.

More about React and React-Native framework analysis

Expand

ReactJS Application

This declaration will create a ReactJS application named App:

Code Block
languagexml
ReactDOM.render(
  <AppContainer>
    <Provider store={store}>
      <App version={appVersion} />
    </Provider>
  </AppContainer>,
  appElement
);

ReactJS Component

This declaration will create a ReactJS component named Sequence because the class inherits from Component (a class that inherits from PureComponent would also induce the creation of a ReactJS component). A component must contain a render method. The render method is automatically called when the component is referred to in an HTML fragment:

Code Block
languagexml
import React from 'react'
import , { Field,Component reduxForm } from 'redux-formreact';
 
let ContactFormclass =Sequence propsextends =>Component {
 
const { handleSubmit } = propsshouldComponentUpdate(nextProps) {
    return (
    <form onSubmit={handleSubmit}>this.props.positionFrom !== nextProps.positionFrom ||
      this.props.sequence !== nextProps.sequence <div>||
        <label htmlFor="firstName">First Name</label>
this.props.nucleotidesPerRow !== nextProps.nucleotidesPerRow ||
       <Field name="firstName" component="input" type="text" />
 this.props.rowHeight !== nextProps.rowHeight;
  }
 
  </div>
render() {
    return <div>(
      <g>
 <label htmlFor="lastName">Last Name</label>         <Field name="lastName" component="input" type="text" />{this.props.sequence.map((nucleotide, index) =>
         </div> <Nucleotide
     <div>       type={nucleotide}
 <label htmlFor="email">Email</label>         <Field name="email" component="input" type="email" />position={this.props.positionFrom + index}
        </div>    key={index}
  <button type="submit">Submit</button>     </form>   ) index={index}
 ContactForm = reduxForm({   // a unique name for the form onClick={this.props.onNucleotideClick}
  form: 'contact'
})(ContactForm)

HTML fragment

This declaration will create a HTML fragment named render_fragment_1 starting with "<g>" and ending with "</g>". There can be several fragments in any function/method:

Code Block
languagexml
render() {
  return (
    <g>       {...this.props.sequence.map((nucleotide, index) =>}
          <Nucleotide/>,
        )}
 type={nucleotide}     </g>
     position={this.props.positionFrom + index}
          key={index}
          index={index}
    );
  }
}

ReactJS Form

This declaration will create a ReactJS form named contact:

Code Block
languagexml
import React from 'react'
import { Field, reduxForm } from 'redux-form'

let ContactForm = props => {
  const { handleSubmit } = props
  return (
    <form onClickonSubmit={this.props.onNucleotideClickhandleSubmit}>
      <div>
   {...this.props}     <label htmlFor="firstName">First Name</label>
 />,       )}
    </g>
  );
}

Links from the ReactJS application

  • A relyon link is created from the application to the HTML fragment of the application.
  • A call link is created from the fragment to the ReactJS component refered to in the fragment
  • A call link is created from the component to the render method of the class representing the component (as render method is automatically called).
  • A call link is created from the render method to the fragment contained inside the render method

Please remember that components are called mainly from html fragments, and render methods are implicitly called from ReactJS components.

Image Removed

Links from a HTML fragment

HTML tags present in HTML fragments are linked to ReactJS components if they exist:

Code Block
    <g><Field name="firstName" component="input" type="text" />
      </div>
      <div>
        <label htmlFor="lastName">Last Name</label>
        <Field name="lastName" component="input" type="text" />
      </div>
      <div>
 <ChildrenLoading 			 dispatch={props.dispatch}     <label htmlFor="email">Email</label>
    	 {...this.props}
		    <Field name="email" component="input" type="email" />
    </g>

Image Removed

HTML tags present in HTML fragments can also be linked to a Typescript function. HTML fragments are linked to functions or methods when they are represented between { ... }:

Code Block
<UserSearchSelect
  dispatch={props.dispatch}
  label={formatMessage({ defaultMessage: 'Transfer to...' })}
/>

Image Removed

Node support

More about supported Nodejs built-in modules 

Nodejs comes along with several built-in modules. Here is a description of the support we provide for some of these modules.

Http, Http2, Https modules

Expand

This extension currently supports the use of these modules for http requests from the client side only (i.e. the use of these modules as server is not yet supported).

The analysis of the previous code will generate Node.js Get HttpRequest service object which is called by my_request function. A link between my_request function and the anonymous handler function is also added. 

Code Block
import * as https from "https"

function my_request(){
  https.get('https://encrypted.google.com/', (res) => {
    console.log('statusCode:', res.statusCode);
    console.log('headers:', res.headers);
}

Image Removed

...

Expand

Nest (NestJS) is a framework for building Node.js server-side applications. Nest provides a level of abstraction above many common Node.js frameworks. The following features provided by nestjs are supported.

Controllers

A controller's purpose is to receive specific requests for the application. A controller is defined using a classe@ and decorators.

The analysis of the following code will create a Node.js Get Operation named cats/all/ with a call link from the operation to the handler method findAll. The url corresponds to the concatenation of the argument of the @Controller decorator with that of the @Get decorator of the method. The decorator of each method defines the type of the operation

Code Block
import { Controller, Get } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Get('/all')
  findAll(): string {
    return 'This action returns all cats';
  }}

Image Removed

Middlewares

Middleware is a function which is called before the route handler. For instance in the following source code, the logger function will be called before each handler of the CatsController. Our analyzer will create a callLink between the operations defined in the CatsController and the logger.

Code Block
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
export function logger(req: Request, res: Response, next: Function) {
  console.log(`Request...`);
  next();
};

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(logger)
      .forRoutes(CatsController);
  }
}

Image Removed

HTTP module

Nestjs allows to perform http requests using the HTTP module. The analysis of the following source code will create a Node.js Get HttpRequest named foo/path/ with a call link from the findAll method to that request:

Code Block
import { HttpService, Injectable, Logger } from '@nestjs/common';

@Injectable()
export class CatsService {
  constructor(private httpService: HttpService) {}

  findAll(): Observable<AxiosResponse<Cat[]>> {
    return this.httpService.get('foo/path');
  }
}

Image Removed

Known limitations

All nestjs features which are not documented here are not supported. 

More about Express framework analysis

...

The analysis of the following code will create a Node.js Get Operation named /login with a call link from the operation to the handler function f:

Code Block
var app = express()
function f(req, res) {
    console.log('login ' + req.url);
    var currentSession = getSessionId(req, res);
}
app.get('/login', f);

Image Removed

Routers are also supported and the analysis of the following code will create a Node.js Get Operation named /foo1/foo2:

Code Block
import express from 'express';

var router = express.Router()

// define the about route
router.get('/foo2', function (req, res) {
  res.send('About birds')
})

var app = express()
app.use('/foo1', router)

...

The analysis of the following code will create a Node.js Get Operation named /login/{} with a call link from the operation to the handler function f:

Code Block
import * as fastify from 'fastify'

function f(request, reply) {
   reply.send({ hello: 'world' })
}

const server: fastify.FastifyInstance<Server, IncomingMessage, ServerResponse> = fastify({})
// Declare a route
server.get('/login/:name', f)

Image Removed

Supported fastify methods are : get, put, post, delete, route

Known limitations

  • prefix are not supported
  • fastify-mongodb is not supported

More about axios framework analysis

...

The analysis of the following code will create a Node.js Put HttpRequest named foo/put/ with a call link from my_func to that request:

Code Block
import * as axios from 'axios';

function my_func(){
  axios('foo/put', {method:'put'})

     .then(function (response) {
       // handle success
       console.log(response);
     })
}

...

More about Sequelize framework analysis

Expand

In the following code: 

Code Block
import * as Sequelize from 'sequelize';

const Model = Sequelize.Model;
class User extends Model {}
User.init({
  // attributes
  firstName: {
    type: Sequelize.STRING,
    allowNull: false
  },
  lastName: {
    type: Sequelize.STRING
    // allowNull defaults to true
  }
}, {
  sequelize,
  modelName: 'user'
  tableName: 'users'
  // options
});
function myfind(){
	User.findAll().then(users => {
  	console.log("All users:", JSON.stringify(users, null, 4));
	});
}

the User class defines a model which is linked with the table named 'users' (through the User.init() call). The name of the table is defined by the tableName value which if not defined is set to the pluralized (if freezeTableName is not set to true) value of modelName which is itself set to the class name when it is not explicitly defined. The User.findAll() call then selects elements from that table 'users'.

In this example, this extension creates a useSelect link to the table 'users':

Image Removed

Note that a model can also be defined using method sequelize.define().

...

Expand

Connection

TypeORM can be used both with SQL and NoSQL databases. The database type is set through the connection option type

Code Block
import {createConnection, Connection} from "typeorm";

const connection = await createConnection({
    type: "mysql",
    host: "localhost",
    port: 3306,
    username: "test",
    password: "test",
    database: "test"
});

The only NoSQL database which is supported by TypeORM is mongodb. A connection object is created by our analyzer only for mongodb databases. The name of the connection is the url mongodb://localhost/test which is constructed using the host and database values.

An Entity is a class that maps to a database table (or collection when using MongoDB):

Code Block
import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity()
export class User {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    firstName: string;

    @Column()
    lastName: string;

    @Column()
    isActive: boolean;

}

When a mongodb database is used, for each entity, the extension creates a MongoDB collection object. A parentLink between that collection and the corresponding connection is added. For an sql connection, the entity will be associated with the sql table having the same name (if that table exists).

Link to table/collection

TypeORM provide several ways to access and/or update a table or collection. One can use an entity manager, a repository or a query builder.

Here is an example with a repository:

Code Block
import {getRepository} from "typeorm";
import {User} from "./user";

function update_user(){
    const userRepository = getRepository(User); 
    const user = await userRepository.findOne(1);
    user.name = "fooname";
    await userRepository.save(user);
}
  • The userRepository.findOne(1) method call generates a "useSelectLink" to the User table/entity.
  • The userRepository.save(user) method call  generates a "useUpdateLink" to the User table/entity.

Example for a mongodb database: both useSelect and useUpdate links are created between the update_user function and the User entity which belongs to the <Default> connection:

Image Removed

Example for a sql database: both useSelect and useUpdate links are created between the update_user function and the user table. 

Image Removed

Cascades

Cascades are supported.
In the following example, the User entity has its column profile with a one-to-one relation with the Profile entity and cascade set to true:

Code Block
import {Entity, PrimaryGeneratedColumn, Column, OneToOne, JoinColumn} from "typeorm";
import {Profile} from "./profile";

@Entity()
export class User {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    name: string;

    @OneToOne(type => Profile, {
        cascade: true
    })
    @JoinColumn()
    profile: Profile;

}

When the profile column of a user instance is saved, if the profile column of that instance was updated with a profile instance, that profile instance is also saved.

Code Block
import {getRepository} from "typeorm";
import {User} from "../entity_dir/user";
import {Profile} from "../entity_dir/profile";


function update_user(){
    const userRepository = getRepository(User); 
    const user = await userRepository.findOne(1);
    const profile = new Profile()
    user.name = "fooname";
    user.profile = profile
    await userRepository.save(user);
}

In the previous example, a useUpdate link is create between the update_user function and both the user and profile tables/entities:

Image Removed

SQL queries

Plain SQL queries can also be carried out using typeORM such as with the following code:

Code Block
import {getConnection} from "typeorm";

export class A {
    public foo() {
        const manager = getConnection().manager;
        const rawData = await manager.query(`SELECT * FROM USER`);
    }
} 

In that example, a TypeScript query object is created and a callLink between the foo method and that query is added. The SQL Analyzer can then link that query with the corresponding table:

Image Removed

Known limitations

The following features are not supported

  • use of ormconfigs.yml, ormconfigs.env and ormconfigs.xm ORM configuration files 

  • custom repositories

  • view entities

  • entity listeners and subscribers

  • connectionManager

More about Mongoose and Mongodb frameworks analysis

See MongoDB support for Node.js source code.

Migration Issue when moving from com.castsoftawre.typescript 1.3.x to >= 1.4.x

...

In 1.3.x, MongoDB Connection and MongoDB Collection objects were added to Typescript Module objects and when a connection (or a collection) is accessed using Mongoose from several files, the analyzer was creating one connection (or collection) object per such file.
In versions >=1.4.x, MongoDB Connection and MongoDB Collection objects are added at the application level and when a connection (or a collection) is accessed using Mongoose from several files the analyzer creates only one connection (or collection).

In order to avoid "added objects" and minimize the number of "deleted objects" when updating from 1.3.x to >=1.4.x a migration is carried out. This migration requires com.castsoftware.internal.platform version >= 0.8.5 to be used.

...

Behavior explanation

Serverless framework, Serverless Application Model (SAM), and Cloudformation are supported. These are frameworks using *.yml or *.json file to set up AWS environment. 
Whenever the runtime set in these files is nodejs, the com.castsoftware.nodejs extension is responsible for creating the corresponding NodeJS AWS Lambda Function, NodeJS AWS Lambda Operation (which represent AWS APIGateway events), and NodeJS AWS Simple Queue objects (see com.castsoftware.nodejs documentation for source codes and example). 

Warning

Since the com.castsoftware.nodejs extension is responsible for analyzing AWS deployment framework *.yml and *.json files the results of an analysis will depend on the version of com.castsoftware.nodjes used.

...

What results can you expect?

When analyzing the following source code with a recent enough version of com.castsoftware.nodejs ( 2.6.0.beta1):

Code Block
provider:
  name: aws
  runtime: nodejs12.x

functions:
  mylambda:
    handler: handler.apilambda
    events:
      - http:
          path: test
          method: get
      - sqs:
          arn:
            Fn::GetAtt:
              - MyQueue
              - Arn     	  
    environment:
      stage: ${opt:stage}
resources:
  Resources:
    MyQueue:
      Type: "AWS::SQS::Queue"
      Properties:
        QueueName: "MyQueue"

Assuming that the handler function is a TypeScript function, once the analysis/snapshot generation has completed, you can view the results in the normal manner (for example via CAST Enlighten):

Click to enlarge

Image Removed

...

Links

...

  • createBucket

...

  • createMultipartUpload

  • createPresignedPost

  • abortMultipartUpload

  • completeMultipartUpload

  • deleteBucketAnalyticsConfiguration

  • deleteBucketCors

  • deleteBucketEncryption

  • deleteBucketInventoryConfiguration

  • deleteBucketLifecycle

  • deleteBucketMetricsConfiguration

  • deleteBucketPolicy

  • deleteBucketReplication

  • deleteBucketTagging

  • deleteBucketWebsite

  • deleteObjectTagging

  • deletePublicAccessBlock

  • getBucketAccelerateConfiguration

  • getBucketAcl

  • getBucketAnalyticsConfiguration

  • getBucketCors

  • getBucketEncryption

  • getBucketInventoryConfiguration

  • getBucketLifecycle

  • getBucketLifecycleConfiguration

  • getBucketLocation

  • getBucketLogging

  • getBucketMetricsConfiguration

  • getBucketNotification

  • getBucketNotificationConfiguration

  • getBucketPolicy

  • getBucketPolicyStatus

  • getBucketReplication

  • getBucketTagging

  • getBucketVersioning

  • getBucketWebsite

  • getObjectAcl

  • getObjectLegalHold

  • getObjectLockConfiguration

  • getObjectRetention

  • getObjectTagging

  • getPublicAccessBlock

  • getSignedUrl

  • listBuckets
  • listBucketAnalyticsConfigurations

  • listBucketInventoryConfigurations

  • listBucketMetricsConfigurations

  • listMultipartUploads

  • listObjectVersions

  • listParts

  • putBucketLogging
  • putBucketAnalyticsConfiguration
  • putBucketLifecycleConfiguration

  • putBucketMetricsConfiguration

  • putBucketNotification

  • putBucketNotificationConfiguration

  • putBucketPolicy

  • putBucketReplication

  • putBucketRequestPayment

  • putBucketTagging

  • putBucketVersioning

  • putObjectAcl

  • putObjectLegalHold

  • putObjectLockConfiguration

  • putObjectRetention

  • putObjectTagging

  • putPublicAccessBlock

  • putBucketAccelerateConfiguration

  • putBucketAcl

  • putBucketCors

  • putBucketEncryption

  • putBucketInventoryConfiguration

  • putBucketLifecycle

  • upload

  • uploadPart

  • uploadPartCopy

...

  • putObject

...

  • deleteBucket
  • deleteObject

  • deleteObjects

...

  • getObject
  • getObjectTorrent
  • listObjects

  • listObjectsV2

...

  • putBucketLogging
  • putBucketAnalyticsConfiguration

Code samples

This code will create a S3 Bucket named "MyBucket" on an AWS server in region "REGION" and puts an object in it

Code Block
languagejs
linenumberstrue
// Load the AWS SDK for Node.js
var AWS = require('aws-sdk');
// Set the region 
AWS.config.update({region: 'REGION'});

// Create S3 service object
s3 = new AWS.S3({apiVersion: '2006-03-01'});

// Create the parameters for calling createBucket
var bucketParams = {
  Bucket : "MyBucket",
  ACL : 'public-read'
};

// call S3 to create the bucket
s3.createBucket(bucketParams, function(err, data) {
  if (err) {
    console.log("Error", err);
  } else {
    console.log("Success", data.Location);
  }
});

params = {
	// ...
    Bucket: "MyBucket"
};
s3.putObject(params, function(err, data) {
    if (err) console.log(err, err.stack); // an error occurred
    else     console.log(data);           // successful response
});

What results can you expect?

Once the analysis/snapshot generation has completed, you can view the results in the normal manner (for example via CAST Enlighten):

Image Removed

Analysis of the code sample

...

Support for SDK

This code will publish a message into the "SQS_QUEUE_URL" queue:

Expand
Links
Link TypeFunction
callLink
  • sendMessage

  • sendMessageBatch
  • receiveMessage
Code Block
languagejs
linenumberstrue
import * as AWS from "aws-sdk";
AWS.config.update({ region: 'REGION' });

const sqs = new AWS.SQS({apiVersion: '2012-11-05'});

const queueUrl = "SQS_QUEUE_URL"

const params = {
	MessageBody: "This is a message",
    QueueUrl: queueUrl,
    MaxNumberOfMessages: 1,
    VisibilityTimeout: 0,
};


sqs.sendMessage(params, function (err, data) {
    if (err) {
        console.log("Error", err);
    } else {
        console.log("Success", data.MessageId);
    }
});
}

This code will receive a message from the queue "SQS_QUEUE_URL"

Code Block
languagejs
linenumberstrue
import * as AWS from "aws-sdk";
AWS.config.update({ region: 'REGION' });

const sqs = new AWS.SQS({apiVersion: '2012-11-05'});

const queueUrl = "SQS_QUEUE_URL"

const params = {
    QueueUrl: queueUrl,
    MaxNumberOfMessages: 1,
    VisibilityTimeout: 0,
};

export class SqsReciver {
    constructor() {
        this.reciver();
    }
    private reciver(): void {
        sqs.receiveMessage(params, (err, data) => {
	// do something
        });
    }
}  </div>
      <button type="submit">Submit</button>
    </form>
  )
}

ContactForm = reduxForm({
  // a unique name for the form
  form: 'contact'
})(ContactForm)

HTML fragment

This declaration will create a HTML fragment named render_fragment_1 starting with "<g>" and ending with "</g>". There can be several fragments in any function/method:

Code Block
languagexml
render() {
  return (
    <g>
      {this.props.sequence.map((nucleotide, index) =>
        <Nucleotide
          type={nucleotide}
          position={this.props.positionFrom + index}
          key={index}
          index={index}
          onClick={this.props.onNucleotideClick}
          {...this.props}
        />,
      )}
    </g>
  );
}

Links from the ReactJS application

  • A relyon link is created from the application to the HTML fragment of the application.
  • A call link is created from the fragment to the ReactJS component referred to in the fragment
  • A call link is created from the component to the render method of the class representing the component (as the render method is automatically called).
  • A call link is created from the render method to the fragment contained inside the render method

Please remember that components are called mainly from html fragments, and render methods are implicitly called from ReactJS components.

Image Added

Links from a HTML fragment

HTML tags present in HTML fragments are linked to ReactJS components if they exist:

Code Block
    <g>
        <ChildrenLoading
			 dispatch={props.dispatch}
          	 {...this.props}
		/>
    </g>

Image Added

HTML tags present in HTML fragments can also be linked to a Typescript function. HTML fragments are linked to functions or methods when they are represented between { ... }:

Code Block
<UserSearchSelect
  dispatch={props.dispatch}
  label={formatMessage({ defaultMessage: 'Transfer to...' })}
/>


Image Added

Node support

More about the support of custom node packages

Expand

It is possible to developp custom node packages. Apackageis a file or a directory that is described by apackage.jsonfile.

An application can combine mutliple packages. The packages can be built together using npm. npm adds these packages to a node_mudules directory. Note that the analyzer will skip everything which is inside a node_modules directory. Users should provide their custom packages at the root of the analyzed source code.


Let's consider a package named my_proj. The root dir contains a package.json file which defines the project name.

Code Block
languageyml
titlemy_proj/package.json
{ "name": "@myprojname"
}

Everything which is exported (or re-exported) from the my_proj/src/index.ts can be imported from any project which uses this package. 

Code Block
titlemy_proj/src/index.ts
export function my_func(){
}

For instance when an other package uses this package, it can import the my_func function using the name of the package for the import:


Code Block
languagejs
titleotherproj/src/foo.ts
import {my_func} from '@myprojname'


function other_func(){
  my_func()	
}

When analyzing these source code, a callLink will be created between other_func and my_func:

Image Added


More about emailing services: nodemailer and sendgrid/mail

Expand

When analyzing the following source code, an email object is created with a callLink from the my_send_mail function

Code Block
languagejs
import * as nodemailer from 'nodemailer';

async function my_send_mail() {
  let transporter = nodemailer.createTransport({
    //...
  });

  // send mail with defined transport object
  let info = await transporter.sendMail({
    from: '"Fred Foo" <foo@example.com>', // sender address
    to: "bar@example.com, baz@example.com", // list of receivers
    //...
  });
}

Image Added


Similarly when analyzing the following source code, an email object is created with a callLink from the my_send_mail function:

Code Block
languagejs
const sgMail = require('@sendgrid/mail');

function my_send_mail(msg){
  sgMail
   .send(msg)
}


Image Added

More about supported Nodejs built-in modules 

Nodejs comes along with several built-in modules. Here is a description of the support we provide for some of these modules.

Http, Http2, Https modules

Expand

This extension currently supports the use of these modules for http requests from the client-side only (i.e. the use of these modules as server is not yet supported).

The analysis of the previous code will generate Node.js Get HttpRequest service object which is called by my_request function. A link between my_request function and the anonymous handler function is also added. 

Code Block
import * as https from "https"

function my_request(){
  https.get('https://encrypted.google.com/', (res) => {
    console.log('statusCode:', res.statusCode);
    console.log('headers:', res.headers);
}

Image Added

Anchor
NestJS
NestJS
More about nestjs framework analysis

Expand

Nest (NestJS) is a framework for building Node.js server-side applications. Nest provides a level of abstraction above many common Node.js frameworks. The following features provided by nestjs are supported.

Controllers

A controller's purpose is to receive specific requests for the application. A controller is defined using a classe@ and decorators.

The analysis of the following code will create a Node.js Get Operation named cats/all/ with a call link from the operation to the handler method findAll. The URL corresponds to the concatenation of the argument of the @Controller decorator with that of the @Get decorator of the method. The decorator of each method defines the type of the operation

Code Block
import { Controller, Get } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Get('/all')
  findAll(): string {
    return 'This action returns all cats';
  }}

Image Added

Middlewares

Middleware is a function that is called before the route handler. For instance, in the following source code, the logger function will be called before each handler of the CatsController. Our analyzer will create a callLink between the operations defined in the CatsController and the logger.

Code Block
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
export function logger(req: Request, res: Response, next: Function) {
  console.log(`Request...`);
  next();
};

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(logger)
      .forRoutes(CatsController);
  }
}

Image Added

HTTP module

Nestjs allows performing http requests using the HTTP module. The analysis of the following source code will create a Node.js Get HttpRequest named foo/path/ with a call link from the findAll method to that request:

Code Block
import { HttpService, Injectable, Logger } from '@nestjs/common';

@Injectable()
export class CatsService {
  constructor(private httpService: HttpService) {}

  findAll(): Observable<AxiosResponse<Cat[]>> {
    return this.httpService.get('foo/path');
  }
}

Image Added

Known limitations

All nestjs features which are not documented here are not supported. 

More about Express framework analysis

Expand

The analysis of the following code will create a Node.js Get Operation named /login with a call link from the operation to the handler function f:

Code Block
var app = express()
function f(req, res) {
    console.log('login ' + req.url);
    var currentSession = getSessionId(req, res);
}
app.get('/login', f);

Image Added

Routers are also supported and the analysis of the following code will create a Node.js Get Operation named /foo1/foo2:

Code Block
import express from 'express';

var router = express.Router()

// define the about route
router.get('/foo2', function (req, res) {
  res.send('About birds')
})

var app = express()
app.use('/foo1', router)


Anchor
Fastify
Fastify
More about fastify framework analysis

Expand

The analysis of the following code will create a Node.js Get Operation named /login/{} with a call link from the operation to the handler function f:

Code Block
import * as fastify from 'fastify'

function f(request, reply) {
   reply.send({ hello: 'world' })
}

const server: fastify.FastifyInstance<Server, IncomingMessage, ServerResponse> = fastify({})
// Declare a route
server.get('/login/:name', f)

Image Added


Supported fastify methods are: get, put, post, delete, route

Known limitations

  • prefixes are not supported
  • fastify-mongodb is not supported

More about request, request-promise, request-promise-native, and request-promise-any frameworks

Expand

The analysis of the following code will create a Node.js Post HttpRequest named foo/post/ with a call link from my_func to that request:

Code Block
import * as rp from 'request-promise-native'

function my_post(){
  var options = {
    method: 'POST',
    uri: 'foo/post',
    body: {
        some: 'payload'
    },
    json: true // Automatically stringifies the body to JSON
  };
 
  rp(options)
    .then(function (parsedBody) {
        // POST succeeded...
    })
    .catch(function (err) {
        // POST failed...
    });
}

Image Added

Similar support is provided for request, request-promise, and request-promise-any frameworks.

More about axios framework analysis

Expand

The analysis of the following code will create a Node.js Put HttpRequest named foo/put/ with a call link from my_func to that request:

Code Block
import * as axios from 'axios';

function my_func(){
  axios('foo/put', {method:'put'})

     .then(function (response) {
       // handle success
       console.log(response);
     })
}

Image Added

More about Sequelize framework analysis

Expand

In the following code: 

Code Block
import * as Sequelize from 'sequelize';

const Model = Sequelize.Model;
class User extends Model {}
User.init({
  // attributes
  firstName: {
    type: Sequelize.STRING,
    allowNull: false
  },
  lastName: {
    type: Sequelize.STRING
    // allowNull defaults to true
  }
}, {
  sequelize,
  modelName: 'user'
  tableName: 'users'
  // options
});
function myfind(){
	User.findAll().then(users => {
  	console.log("All users:", JSON.stringify(users, null, 4));
	});
}

the User class defines a model which is linked with the table named 'users' (through the User.init() call). The name of the table is defined by the tableName value which if not defined is set to the pluralized (if freezeTableName is not set to true) value of modelName which is itself set to the class name when it is not explicitly defined. The User.findAll() call then selects elements from that table 'users'.

In this example, this extension creates a useSelect link to the table 'users':

Image Added

Note that a model can also be defined using method sequelize.define().

Anchor
TypeORM
TypeORM
More about TypeORM framework analysis

Expand

Connection

TypeORM can be used both with SQL and NoSQL databases. The database type is set through the connection option type

Code Block
import {createConnection, Connection} from "typeorm";

const connection = await createConnection({
    type: "mysql",
    host: "localhost",
    port: 3306,
    username: "test",
    password: "test",
    database: "test"
});

The only NoSQL database which is supported by TypeORM is mongodb. A connection object is created by our analyzer only for mongodb databases. The name of the connection is the URL mongodb://localhost/test which is constructed using the host and database values.

An Entity is a class that maps to a database table (or collection when using MongoDB):

Code Block
import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity()
export class User {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    firstName: string;

    @Column()
    lastName: string;

    @Column()
    isActive: boolean;

}

When a mongodb database is used, for each entity, the extension creates a MongoDB collection object. A parentLink between that collection and the corresponding connection is added. For an SQL connection, the entity will be associated with the SQL table having the same name (if that table exists).

Link to table/collection

TypeORM provide several ways to access and/or update a table or collection. One can use an entity manager, a repository, or a query builder.

Here is an example with a repository:

Code Block
import {getRepository} from "typeorm";
import {User} from "./user";

function update_user(){
    const userRepository = getRepository(User); 
    const user = await userRepository.findOne(1);
    user.name = "fooname";
    await userRepository.save(user);
}
  • The userRepository.findOne(1) method call generates a "useSelectLink" to the User table/entity.
  • The userRepository.save(user) method call  generates a "useUpdateLink" to the User table/entity.

Example for a mongodb database: both useSelect and useUpdate links are created between the update_user function and the User entity which belongs to the <Default> connection:

Image Added

Example for a SQL database: both useSelect and useUpdate links are created between the update_user function and the user table. 

Image Added

Cascades

Cascades are supported.
In the following example, the User entity has its column profile with a one-to-one relation with the Profile entity and cascade set to true:

Code Block
import {Entity, PrimaryGeneratedColumn, Column, OneToOne, JoinColumn} from "typeorm";
import {Profile} from "./profile";

@Entity()
export class User {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    name: string;

    @OneToOne(type => Profile, {
        cascade: true
    })
    @JoinColumn()
    profile: Profile;

}

When the profile column of a user instance is saved, if the profile column of that instance was updated with a profile instance, that profile instance is also saved.

Code Block
import {getRepository} from "typeorm";
import {User} from "../entity_dir/user";
import {Profile} from "../entity_dir/profile";


function update_user(){
    const userRepository = getRepository(User); 
    const user = await userRepository.findOne(1);
    const profile = new Profile()
    user.name = "fooname";
    user.profile = profile
    await userRepository.save(user);
}

In the previous example, a useUpdate link is created between the update_user function and both the user and profile tables/entities:

Image Added

SQL queries

Plain SQL queries can also be carried out using typeORM such as with the following code:

Code Block
import {getConnection} from "typeorm";

export class A {
    public foo() {
        const manager = getConnection().manager;
        const rawData = await manager.query(`SELECT * FROM USER`);
    }
} 

In that example, a TypeScript query object is created and a callLink between the foo method and that query is added. The SQL Analyzer can then link that query with the corresponding table:

Image Added

Known limitations

The following features are not supported

  • use of ormconfigs.yml, ormconfigs.env and ormconfigs.xm ORM configuration files 

  • custom repositories

  • view entities

  • entity listeners and subscribers

  • connectionManager

More about Mongoose and Mongodb frameworks analysis

See MongoDB support for Node.js source code.

Migration Issue when moving from com.castsoftawre.typescript 1.3.x to >= 1.4.x

Expand

In 1.3.x, MongoDB Connection and MongoDB Collection objects were added to Typescript Module objects and when a connection (or a collection) is accessed using Mongoose from several files, the analyzer was creating one connection (or collection) object per such file.
In versions >=1.4.x, MongoDB Connection and MongoDB Collection objects are added at the application level and when a connection (or a collection) is accessed using Mongoose from several files the analyzer creates only one connection (or collection).

In order to avoid "added objects" and minimize the number of "deleted objects" when updating from 1.3.x to >=1.4.x a migration is carried out. This migration requires com.castsoftware.internal.platform version >= 0.8.5 to be used.


Note that if the same connection (or collection) is accessed from different ts modules when analyzing with com.castsoftware.typescript 1.3.x several MongoDB Connection (or MongoDB Collection) objects are created whereas only one object is created with versions >=1.4.x. In such case, there would be "deleted objects" during the migration.

Anchor
AWSTypescript
AWSTypescript
More about AWS frameworks analysis

Anchor
AWSLambda
AWSLambda
AWS lambda

Expand

Behavior explanation

Lambda services allow executing some source code on the cloud and define when this source code should be executed. 

Lambda functions can be deployed using several deployment frameworks. The supported deployment frameworks are listed on this page.

When a lambda function is created and its runtime is nodejs, the current extension is responsible for linking the lambda objects and their triggers with the TypeScript handler functions.

Example

Let us consider a source code defining a lambda function that has two triggers: an SQS queue and an API Gateway. The lambda function has a nodejs runtime and the handler function is given by the handler function fullname. 

If the lambda function is deployed using a supported deployment framework (such as CloudConfiguration), the analysis will create a lambda function, an SQS receiver, and an API Gateway objects. Each of these objects has a runtime property (nodejs) and a handler property with the function fullname. 

If the current extension finds a TypeScript method matching the handler fullname a link to that TypeScript method will be added from the lambda function, the SQS queue and the API Gateway objects:

Click to enlarge

Image Added


Anchor
AWSS3
AWSS3
AWS S3 framework analysis

Expand

Links

Link TypeFunction
No Link
  • createBucket
callLink
  • createMultipartUpload

  • createPresignedPost

  • abortMultipartUpload

  • completeMultipartUpload

  • deleteBucketAnalyticsConfiguration

  • deleteBucketCors

  • deleteBucketEncryption

  • deleteBucketInventoryConfiguration

  • deleteBucketLifecycle

  • deleteBucketMetricsConfiguration

  • deleteBucketPolicy

  • deleteBucketReplication

  • deleteBucketTagging

  • deleteBucketWebsite

  • deleteObjectTagging

  • deletePublicAccessBlock

  • getBucketAccelerateConfiguration

  • getBucketAcl

  • getBucketAnalyticsConfiguration

  • getBucketCors

  • getBucketEncryption

  • getBucketInventoryConfiguration

  • getBucketLifecycle

  • getBucketLifecycleConfiguration

  • getBucketLocation

  • getBucketLogging

  • getBucketMetricsConfiguration

  • getBucketNotification

  • getBucketNotificationConfiguration

  • getBucketPolicy

  • getBucketPolicyStatus

  • getBucketReplication

  • getBucketTagging

  • getBucketVersioning

  • getBucketWebsite

  • getObjectAcl

  • getObjectLegalHold

  • getObjectLockConfiguration

  • getObjectRetention

  • getObjectTagging

  • getPublicAccessBlock

  • getSignedUrl

  • listBuckets
  • listBucketAnalyticsConfigurations

  • listBucketInventoryConfigurations

  • listBucketMetricsConfigurations

  • listMultipartUploads

  • listObjectVersions

  • listParts

  • putBucketLogging
  • putBucketAnalyticsConfiguration
  • putBucketLifecycleConfiguration

  • putBucketMetricsConfiguration

  • putBucketNotification

  • putBucketNotificationConfiguration

  • putBucketPolicy

  • putBucketReplication

  • putBucketRequestPayment

  • putBucketTagging

  • putBucketVersioning

  • putObjectAcl

  • putObjectLegalHold

  • putObjectLockConfiguration

  • putObjectRetention

  • putObjectTagging

  • putPublicAccessBlock

  • putBucketAccelerateConfiguration

  • putBucketAcl

  • putBucketCors

  • putBucketEncryption

  • putBucketInventoryConfiguration

  • putBucketLifecycle

  • upload

  • uploadPart

  • uploadPartCopy

useInsertLink
  • putObject
useDeleteLink
  • deleteBucket
  • deleteObject

  • deleteObjects

useSelectLink
  • getObject
  • getObjectTorrent
  • listObjects

  • listObjectsV2

useUpdateLink
  • putBucketLogging
  • putBucketAnalyticsConfiguration

Code samples

This code will create an S3 Bucket named "MyBucket" on an AWS server in region "REGION" and puts an object in it

Code Block
languagejs
linenumberstrue
// Load the AWS SDK for Node.js
var AWS = require('aws-sdk');
// Set the region 
AWS.config.update({region: 'REGION'});

// Create S3 service object
s3 = new AWS.S3({apiVersion: '2006-03-01'});

// Create the parameters for calling createBucket
var bucketParams = {
  Bucket : "MyBucket",
  ACL : 'public-read'
};

// call S3 to create the bucket
s3.createBucket(bucketParams, function(err, data) {
  if (err) {
    console.log("Error", err);
  } else {
    console.log("Success", data.Location);
  }
});

params = {
	// ...
    Bucket: "MyBucket"
};
s3.putObject(params, function(err, data) {
    if (err) console.log(err, err.stack); // an error occurred
    else     console.log(data);           // successful response
});

What results can you expect?

Once the analysis/snapshot generation has completed, you can view the results in the normal manner (for example via CAST Enlighten):

Image Added

Analysis of the code sample




Anchor
SQSTypeScript
SQSTypeScript
AWS SQS framework analysis

Expand
Links
Link TypeFunction
callLink
  • sendMessage

  • sendMessageBatch
  • receiveMessage
Support for SDK

This code will publish a message into the "SQS_QUEUE_URL" queue:

Code Block
languagejs
linenumberstrue
import * as AWS from "aws-sdk";
AWS.config.update({ region: 'REGION' });

const sqs = new AWS.SQS({apiVersion: '2012-11-05'});

const queueUrl = "SQS_QUEUE_URL"

const params = {
	MessageBody: "This is a message",
    QueueUrl: queueUrl,
    MaxNumberOfMessages: 1,
    VisibilityTimeout: 0,
};


sqs.sendMessage(params, function (err, data) {
    if (err) {
        console.log("Error", err);
    } else {
        console.log("Success", data.MessageId);
    }
});
}

This code will receive a message from the queue "SQS_QUEUE_URL"

Code Block
languagejs
linenumberstrue
import * as AWS from "aws-sdk";
AWS.config.update({ region: 'REGION' });

const sqs = new AWS.SQS({apiVersion: '2012-11-05'});

const queueUrl = "SQS_QUEUE_URL"

const params = {
    QueueUrl: queueUrl,
    MaxNumberOfMessages: 1,
    VisibilityTimeout: 0,
};

export class SqsReciver {
    constructor() {
        this.reciver();
    }
    private reciver(): void {
        sqs.receiveMessage(params, (err, data) => {
	// do something
        });
    }
}
What results can you expect?

Once the analysis/snapshot generation has been completed, you can view the results in the standard manner (for example via CAST Enlighten):

Click to enlarge

Image Added

When the evaluation of the queue name fails, a Node.js AWS SQS Unknown Publisher (or Receiver) will be created.

Support for AWS XRay


Expand

aws-xray encapsulates AWS methods calls in order to provide status and load status. However, the encapsulation did not allow the extension to provide objects and links. With the support of AWS XRay starting in 2.6.0-beta4, these objects and links will be created.

Code samples

This code will encapsulate AWS SDK then create a dynamoDB instance, and a Table instance.


Code Block
languagejs
import AWSXRay from 'aws-xray-sdk-core'
import AWS from 'aws-sdk'
const AWS = AWSXRay.captureAWS(AWS) // Encapsulate AWS SDK
const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" }) // use AWS as usual
const { v1: uuidv1 } = require('uuid');
 
// environment variables
const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env
const options = { region: REGION }
AWS.config.update({ region: REGION })
 
if (ENDPOINT_OVERRIDE !== "") {
    options.endpoint = ENDPOINT_OVERRIDE
}
 
const docClient = new AWS.DynamoDB.DocumentClient(options)
// response helper
const response = (statusCode, body, additionalHeaders) => ({
    statusCode,
    body: JSON.stringify(body),
    headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', ...additionalHeaders },
})
 

 
function addRecord(event) {
 
    let usernameField = {
        "cognito-username": getCognitoUsername(event)
    }
 
    // auto generated date fields
    let d = new Date()
    let dISO = d.toISOString()
    let auto_fields = {
        "id": uuidv1(),
        "creation_date": dISO,
        "lastupdate_date": dISO
    }
 
    //merge the json objects
    let item_body = {...usernameField, ...auto_fields, ...JSON.parse(event.body) }
 
    console.log(item_body);
     
    //final params to DynamoDB
    const params = {
        TableName: TABLE_NAME,
        Item: item_body
    }
 
    return docClient.put(params)
}
 


What results can you expect?

Once the analysis/snapshot generation has been completed, you can view the results in the normal manner (for example via CAST Enlighten):

Click to enlarge

Image Removed

When the evaluation of the queue name fails, a Node.js AWS SQS Unknown Publisher (or Receiver) will be created.

AWS Lambda framework analysis

...

with your favorite tool (for example via CAST Enlighten):

Click to enlarge

Image Added

Analysis of the code sample

Known limitations for AWS support

  • The use of AWS.SQS with promises is not supported. For instance, no link would be created between the receiver and the handler function defined in .then() call in the following source code: 

    Code Block
    languagexml
    this.sqs.receiveMessage(params).promise().then( () => {})


  • If the queueName is set using the createQueue apiAPI, the evaluation of the queue name will fail.

...

Expand

In the following code: 

Code Block
var oracledb = require('oracledb');
 
oracledb.getConnection(
  {
    user          : "hr",
    password      : "welcome",
    connectString : "localhost/XE"
  },
  function doSelect(err, connection)
  {
    if (err) { console.error(err); return; }
    connection.execute(
      "SELECT department_id, department_name "
    + "FROM titles "
    + "WHERE department_id < 70 "
    + "ORDER BY department_id",
      function(err, result)
      {
        if (err) { console.error(err); return; }
        console.log(result.rows);
      });
  });
};

In this example, a TypeScript query object is created and a callLink between the anonymous function and that query is added. The sql analyzer can then link that query with the corresponding table if the table exists. In the present case, this extension creates a useSelect link to the table 'titles':

Image Removed

Links

Analysis of the TypeScript application will result in the following links:

  • callLink: Created when a method or a function is called. These links connect TypeScript Method and TypeScript Function elements between them.
  • inheritLink: Represents direct inheritance between TypeScript Class and TypeScript Interface objects.

...

In this example, a TypeScript query object is created and a callLink between the anonymous function and that query is added. The sql analyzer can then link that query with the corresponding table if the table exists. In the present case, this extension creates a useSelect link to the table 'titles':

Image Added

Links

Analysis of the TypeScript application will result in the following links:

  • callLink: Created when a method or a function is called. These links connect TypeScript Method and TypeScript Function elements between them.
  • inheritLink: Represents direct inheritance between TypeScript Class and TypeScript Interface objects.

Anchor
rules
rules
Rules

The following rules are shipped with this extension:

...

Info

The rule "Avoid too many copy-pasted artifacts" depends on com.castsoftware.html5 extension. It will be activated automatically for TypeScript source code when using a version of com.castsoftware.html5 >= 2.0.15-funcrel.

...

  • Limitations for support of the following frameworks are given in their own section:
  • Use
  • Calls between JavaScript and TypeScript source codes are not supported.
  • The use of setters and getters is not supported.
  • Passing directly url strings Passing the URL strings directly (or string variables referring to urlsURLs) as arguments to web-service calls is supported for many use cases. However, passing them through http.RequestOptions (containing metadata) is work in progress.
  • String concatenations using the operator '+' inside loops does do not raise violations currently.
  • The cyclomatic complexity number might appear underestimated in callables containing loops with complex conditional expressions.
  • A single production environment file is supported (see corresponding section above).
  • Use The use of bind method is not supported and would lead to missing callLinks.
  • Use The use of Object.freeze method is not supported.
  • React Without JSX is not supported.
  • The spread operator "..." is not supported.