Page tree
Skip to end of metadata
Go to start of metadata

This extension was previously (in version 1.0, 1.1, and 1.2) known as TypeScript and Angular.

On this page:


Target audience:

Users of the extension providing support for the TypeScript language. It also includes support for Angular, ReactReact-Native and some of the main frameworks for Node.js Web applications such as Express (when they are used within typescript source code).

Summary: This document provides information about the extension providing TypeScript, Angular, React and Node support for Web applications.

Extension ID

com.castsoftware.typescript

What's new

See TypeScript and Frameworks - 1.6 - Release Notes for more information.

Description

This extension provides support for the TypeScript language. It also includes support for Angular, React, React-Native and some of the main frameworks for Node.js Web applications such as Express (when they are used within typescript source code).

  • 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 for Node.js.
    • Mongoose is a MongoDB object modelling tool designed to work in an asynchronous environment.
    • AWS S3 is a storage service by Amazon 
    • TypeORM is an Object-Relational Mapping framework
    • Sequelize is a framework for database management 

Note that:

  • in order to analyze a JavaScript source code which uses Express framework, you should use the Node.js extension.
  • similarly, in order to analyze a JavaScript source code which uses the Angular framework, you should use the AngularJS extension.
  • finally, in order to analyze a JavaScript source code which uses the React or React-Native framework, you should use the ReactJS extension.

In what situation should you install this extension?

The typical use case would be a full-stack web application developed entirely in TypeScript using Angular framework and Node.js. However, this extension should be used whenever any sub-set of the application is implemented using TypeScript (provided that you want to view the call-graph of that part of the application). 

Angular/TypeScript Front-end connected to Node.js/Express/MongoDB back-end

Supported versions

The following tables display the list of versions that this extension supports. It also gives a list of the supported frameworks for Node.js.

TypeScript

VersionSupported
1.x

(tick) 

2.x

(tick)

3.x

(tick)

Angular

VersionSupported
2

(tick)

4

(tick)

5

(tick)

6

(tick)

7

(tick)

8(tick)
9(tick)
10(tick)

React

VersionSupported
15.x

(tick)

16.x

(tick)

React-Native

VersionSupported

0.x

(tick)

Supported Node.js versions

VersionSupport Comment
v0.x

(error)

No longer supported
v4.x

 (tick)

LTS
v5.x

 (tick)

Based on Javascript ES6
v6.x

 (tick)

Based on Javascript ES6
v7.x(tick)Based on Javascript ES6
v8.x

(tick)


v9.x

(tick) 


v10.x

(tick)


v11.x

(tick)


v12.x

(tick)


v13.x

(tick)


Supported frameworks for Node.js

  • (tick) indicates that the framework is currently supported.
  • (error) indicates that the framework is not yet supported.

Library

Comment

Data Access

Web Service

Supported versions

ExpressNode.js application framework
(tick)4.x; 5.x
MongooseMongoDB access(tick)
5.x
SequelizeNode.js application framework(tick)
5.x
TypeORMORM(tick)
0.2.x
Mode-mongodb-nativeMongoDB access(error)

Mongo-clientMongoDB access(error)

CouchdbCouchdb access(error)

Node-couchdbCouchdb access(error)

Couchdb-nanoCouchdb access(error)

MarklogicMarklogic access(error)

my_connectionMySQL access(tick)

pgPostgreSQL access(tick)

oracledbOracle Database access(tick)

node-sqlserver

MsnodeSQL access(tick)

mssql

MsSQL access(tick) 

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.DynamoDBAmazon database access(error)

AWS.S3Amazon storage service(tick)

AWS.LambdaAmazon routing solution
(error)

Files analyzed

Icon(s)FileExtension

TypeScript.ts

TypeScript.tsx

Skipped 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:

  • Function Points (transactions): a green tick indicates that OMG Function Point counting and Transaction Risk Index are supported
  • Quality and Sizing: a green tick indicates that CAST can measure size and that a minimum set of Quality Rules exist

Function Points
(transactions)
Quality and Sizing
TypeScript(tick)(tick)
Angular(tick)(tick)
React(tick)(tick)
Express(tick)(error)
Mongoose(tick)(error)
Sequelize(tick)(error)
TypeORM(tick)(error)

CAST AIP compatibility

This extension is compatible with:

CAST AIP release

Supported

8.3.x(tick)
8.2.x(tick)
8.1.x(tick)
8.0.x(tick)
7.3.4 and all higher 7.3.x releases(tick)

Supported DBMS servers

This extension is compatible with the following DBMS servers:

CAST AIP releaseCSSOracleMicrosoft
All supported releases(tick)(tick)(tick)

Prerequisites

(tick)An installation of any compatible release of CAST AIP (see table above)

Dependencies with other extensions

Some CAST extensions require the presence of other CAST extensions in order to function correctly. The TypeScript and frameworks extension requires that the following other CAST extensions are also installed:

Note that when using the CAST Extension Downloader to download the extension and the Manage Extensions interface in CAST Server Manager to install the extension, the HTML5/JavaScript, ReactJS and NodeJS extensions will be installed automatically. You do not need to do anything.

Download and installation instructions

Please see:

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:

 Click here to expand...

Packaging and delivery

Note that the TypeScript and Angular extension does not contain any CAST Delivery Manager Tool discoverers or extractors, therefore, no "TypeScript and Angular" projects will be detected by the CAST Delivery Manager Tool. You therefore have two choices:

  • manually create an Analysis Unit in the CAST Management Studio.
  • or download and install the Web Files Discoverer to automatically detect projects in the CAST Delivery Manager and therefore Analysis Units in the CAST Management Studio.

Using the CAST Delivery Manager Tool:

  • create a new Version
  • create a new Package for your TypeScript and Angular source code using the Files on your file system option:

  • Define the root folder of your Application source code:

  • Run the Package action
  • Before delivering the source code, check the packaging results:
Without the Web Files Discover

If you are not using the Web Files Discoverer, the following will occur:

  • the CAST Delivery Manager Tool will not find any "projects" related to the TypeScript and Angular application source code - this is the expected behaviour. However, if your TypeScript and Angular related source code is part of a larger application (for example a JEE application), then other projects may be found during the package action (click to enlarge):

With the Web Files Discoverer

If you are using the Web Files Discoverer, the following will occur:

  • the CAST Delivery Manager Tool will automatically detect "HTML5 file projects" (see Web Files Discoverer for more technical information about how the discoverer works) related to the TypeScript and Angular application source code. In addition, if your TypeScript and Angular related source code is part of a larger application (for example a JEE application), then other projects may also be found during the package action (click to enlarge):

  • Deliver the Version

Analyzing

Using the CAST Management Studio:

  • Accept and deploy the Version in the CAST Management Studio.
Without the Web Files Discover

If you are not using the Web Files Discoverer, the following will occur:

  • No Analysis Units will be created automatically relating to the TypeScript and Angular source code - this is the expected behaviour. However, if your TypeScript and Angular related source code is part of a larger application (for example a JEE application), then other Analysis Units may be created automatically:

  • In the Current Version tab, add a new Analysis Unit specifically for your TypeScript and Angular source code, selecting the Add new Universal Analysis Unit option:

  • Edit the new Analysis Unit and configure in the Source Settings tab:
    • a name for the Analysis Unit
    • ensure you tick the HTML5/JavaScript option (the TypeScript and Angular extension depends on the HTML5 and JavaScript extension - and therefore the Universal Analyzer language for the AngularJS extension is set as HTML5/JavaScript)
    • define the location of the deployed TypeScript and Angular source code (the CAST Management Studio will locate this automatically in the Deployment folder):

  • Run a test analysis on the Analysis Unit before you generate a new snapshot.
With the Web Files Discoverer

If you are using the Web Files Discoverer, the following will occur:

  • "HTML5" Analysis Units will be created automatically (see Web Files Discoverer for more technical information about how the discoverer works) related to the TypeScript and Angular application source code. In addition, if your TypeScript and Angular related source code is part of a larger application (for example a JEE application), then other Analysis Units may also be created:

  • There is nothing further to do, you can now run a test analysis on the Analysis Unit before you generate a new snapshot.

What results can you expect?

Once the analysis/snapshot generation has completed, you can view the results in the normal manner:


In this full-stack example, the front-end is implemented in TypeScript and uses Angular and the back-end is implemented in JavaScript and uses Express and MongoDB. If analyzing a web-application with the back-end implemented in TypeScript, the data-base access would be missing since this extension does not yet support any database access framework.

Objects

The following objects are identified:

IconMetamodel nameCode Reference (example)

Typescript Module

Typescript Namespace
namespace A {
     
    // not exported
    function a() {
    }
}

Typescript Class
export class TodoStorage implements ... {


...     
}

Class Initializer
export class TodoStorage implements ... {

field = new Todo();

...     
}

Typescript Method
export class TodoStorage implements ... {

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


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

Typescript Interface
export interface ITodoScope extends... {


...     
}

Typescript Function
// 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

More about Typescript analysis 

 Click here to 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();

}

 

More about Angular framework analysis

 Click here to 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.

example 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.:

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. 

Link 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:

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.

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


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

More about React and React-Native framework analysis

 Click here to expand...

ReactJS Application

This declaration will create a ReactJS application named App:

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:

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:

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

let ContactForm = props => {
  const { handleSubmit } = props
  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label htmlFor="firstName">First Name</label>
        <Field name="firstName" component="input" type="text" />
      </div>
      <div>
        <label htmlFor="lastName">Last Name</label>
        <Field name="lastName" component="input" type="text" />
      </div>
      <div>
        <label htmlFor="email">Email</label>
        <Field name="email" component="input" type="email" />
      </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:

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 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.

Links from a HTML fragment

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

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

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 { ... }:

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

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

 Click here to 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. 

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);
}

More about 

More about Express framework analysis

 Click here to 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:

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

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

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)

More about Sequelize framework analysis

 Click here to expand...

In the following code: 

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':

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

More about TypeORM framework analysis

 Click here to expand...

Connection

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

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):

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 exemple with a repository:

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.


Exemple 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:

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

Cascades

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

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.

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 exemple, a useUpdate link is create between the update_user function and both the user and profile tables/entities:

SQL queries

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

import {getConnection} from "typeorm";

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

In that exemple, 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:

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 framework analysis

See MongoDB support for Node.js source code

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

 Click here to 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.

More about AWS S3 framework analysis

See AWS S3 support for Node.js source code

SQL Database Access

This extension supports some libraries offering access to SQL databases. The SQL frameworks analysis is based on the evaluation of the first argument of the "query()" and "execute()" method calls. The first argument is evaluated and if it corresponds to an SQL query, a CAST_TS_Query object is created. In the case where the first argument does not correspond to a SQL query, we evaluate the second argument if is exists. Text only and parameterized SQL queries are supported. This heuristic allows us to support a large number of SQL database frameworks.

More about PostgreSQL "pg" framework analysis

 Click here to expand...

In the following code: 

var pg = require("pg");
var conString = "pg://operator:CastAIP@localhost:2280/postgres";
var client = null;

function getTables(schema, cbTables) {
    "use strict";
    client = new pg.Client(conString);
    client.connect();
    var queryTables = client.query("SELECT table_name FROM information_schema.tables WHERE table_schema='" + 
                      schema + "' ORDER BY 	table_name");

    queryTables.on("row", function (row, result) {
        result.addRow(row);
    });
    queryTables.on("end", function (result) {
        var tables = [];
        for (i = 0; i < result.rows.length; i += 1) {
            tables.push(result.rows[i].table_name);
        }
        client.end();
        cbTables(tables);
    });
};

In this exemple, a TypeScript query object is created and a callLink between the getTables method 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 'tables':

More about MySQL framework analysis

 Click here to expand...

In the following code: 

var connection = require('my_connection');
var router = express.Router();
var connection = require('my_connection');

router.get('/', function(req, res, next) {
	function getMostUsedApps() {
		var getmostusedapps = "SELECT a.created_by,a.name,a.category_id,t.app_id as id,COUNT(t.app_id) 
                               AS  total,a.serviceUrl,a.contractId," + "c.name as catname,p.company_name 
                               FROM track_ussd t "+ "RIGHT JOIN apps a ON t.app_id = a.id INNER JOIN categories c" + 
                               " ON a.category_id = c.id INNER JOIN profiles p ON a.created_by = p.user_id WHERE 
                               t.msisdn = '"+msisdn+"' AND a.status = 'ACTIVATE'" + "GROUP BY t.app_id ORDER BY total DESC LIMIT 3";
		
		connection.query(getmostusedapps, function(err_getmostusedapps, rows_getmostusedapps, fields_getmostusedapps) {
			render(rows_getmostusedapps);
		});
	};
});

In this exemple, a TypeScript query object is created and a callLink between the getMostUsedApps method 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 tables 'track_ussd', 'categories', 'apps':

More about MS SQL framework analysis

 Click here to expand...

In the following code: 

var sql = require('mssql');

app.delete('/rest/todos/:todo_id', function doDelete(req, res) {
    'use strict';
    var id = req.params.todo_id,
        query = 'DELETE FROM TODO WHERE ID=\'' + id + '\'';
    new sql.Request().query(query, function (error) {
        if (error) {
            console.log('delete', error);
            res.status(404).send('Error when clearing completed TODOs.');
            return;
        }
        res.end();
    });
});

In this exemple, 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 useDelete link to the table 'TODO':

More about MS SQL "node-sqlserver" framework analysis

 Click here to expand...

In the following code: 

var sql = require('node-sqlserver');

var connStr = "Driver={SQL Server Native Client 11.0};Server=myySqlDb,1433;Database=DB;UID=Henry;PWD=cat;";
var query = "SELECT * FROM GAData WHERE TestID = 17";

sql.open(connStr, function doSelect(err,conn){
    if(err){
        return console.error("Could not connect to sql: ", err);
    }

	conn.queryRaw("SELECT TOP 10 FirstName, LastName FROM authors", function (err, results) {
        if (err) {
            console.log("Error running query!");
            return;
        }
        for (var i = 0; i < results.rows.length; i++) {
            console.log("FirstName: " + results.rows[i][0] + " LastName: " + results.rows[i][1]);
        }
    });
});

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 'authors':

More about OracleDB framework analysis

 Click here to expand...

In the following code: 

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 exemple, 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':

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.

Rules

The following rules are shipped with this extension:

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

  • Connectivity between components through Angular routing is not supported.
  • Use of HttpRequest in Angular is not supported
  • Use of setters and getters is not supported.
  • Passing directly url strings (or string variables referring to urls) 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 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 of bind method is not supported and would lead to missing callLinks.
  • Use of Object.freeze method is not supported.
  • React Without JSX is not supported.
  • The spread operator "..." is not supported.


  • No labels