feat(core): initial code commit

Author: grantila

.github/workflows/branches.yml

@@ -0,0 +1,32 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Branches
+
+on:
+  push:
+    branches-ignore:
+      - master
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version:
+          - 12.x
+          - 14.x
+          - 15.x
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn
+    - run: yarn build
+    - run: yarn test
+      env:
+        CI: true

.github/workflows/master.yml

@@ -0,0 +1,57 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Master
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version:
+          - 12.x
+          - 14.x
+          - 15.x
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn
+    - run: yarn build
+    - run: yarn test
+      env:
+        CI: true
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+      - name: Setup Node.js
+        uses: actions/setup-node@v1
+        with:
+          node-version: 14
+      - run: yarn
+      - run: yarn build
+      - run: yarn test
+        env:
+          CI: true
+      - name: Coveralls
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npx semantic-release

.gitignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+coverage
+yarn.lock

jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+	preset: 'ts-jest',
+	testEnvironment: 'node',
+	coverageReporters: [ 'lcov', 'text', 'html' ],
+};

lib/index.test.ts

@@ -0,0 +1,182 @@
+import { analyzeTypes, sortTypeAnalysisResult } from './index'
+
+
+function expectEqual< T >( got: T, expected: T )
+{
+	expect( got ).toStrictEqual( expected );
+}
+
+describe( "analyzeTypes", ( ) =>
+{
+	it( "no definition", ( ) =>
+	{
+		expectEqual(
+			analyzeTypes( { } ),
+			{
+				entrypoints: [ ],
+				cycles: [ ],
+				all: [ ],
+				dependencies: [ ],
+				graph: [ ],
+			}
+		);
+	} );
+
+	it( "no types", ( ) =>
+	{
+		expectEqual(
+			analyzeTypes( { definitions: { } } ),
+			{
+				entrypoints: [ ],
+				cycles: [ ],
+				all: [ ],
+				dependencies: [ ],
+				graph: [ ],
+			}
+		);
+	} );
+
+	it( "simple type", ( ) =>
+	{
+		expectEqual(
+			analyzeTypes( { definitions: { User: { } } } ),
+			{
+				entrypoints: [ ],
+				cycles: [ ],
+				all: [ ],
+				dependencies: [ ],
+				graph: [ [ 'User', [ ] ] ],
+			}
+		);
+	} );
+
+	it( "single recursive type", ( ) =>
+	{
+		const definitions = {
+			User: {
+				type: 'object',
+				properties: {
+					parent: { $ref: '#/definitions/User' },
+				},
+			},
+		};
+		expectEqual(
+			analyzeTypes( { definitions } ),
+			{
+				entrypoints: [ ],
+				cycles: [ [ 'User' ] ],
+				all: [ 'User' ],
+				dependencies: [ ],
+				graph: [ [ 'User', [ 'User' ] ] ],
+			}
+		);
+	} );
+
+	it( "complex typings", ( ) =>
+	{
+		const jsonSchema = {
+			definitions: {
+				Link: {}, // Non-cyclic but dependency of Message
+				Subscriber: {
+					type: 'object',
+					properties: {
+						user: { $ref: '#/definitions/User' },
+					},
+				},
+				Message: {
+					type: 'object',
+					properties: {
+						replyTo: { $ref: '#/definitions/Message' },
+						link: { $ref: '#/definitions/Link' },
+						subscriber: { $ref: '#/definitions/Subscriber' },
+					},
+				},
+				User: {
+					type: 'object',
+					properties: {
+						parent: { $ref: '#/definitions/User' },
+						lastMessage: { $ref: '#/definitions/Message' },
+					},
+				},
+				DM: {
+					type: 'object',
+					properties: {
+						lastUser: { $ref: '#/definitions/User' },
+					},
+				},
+				Actions: {
+					type: 'object',
+					properties: {
+						dms: {
+							type: 'array',
+							items: { $ref: '#/definitions/DM' },
+						},
+					},
+				},
+				// Has dependencies, but nothing cyclic
+				Product: { $ref: '#/non-local-dep/Foo' },
+				Cart: {
+					type: 'array',
+					items: { $ref: '#/definitions/Product' },
+				},
+			}
+		};
+
+		expectEqual(
+			sortTypeAnalysisResult( analyzeTypes( jsonSchema ) ),
+			sortTypeAnalysisResult( {
+				entrypoints: [
+					[ "DM" ],
+					[ "Actions", "DM" ],
+				],
+				cycles: [
+					[ 'User' ],
+					[ 'Message' ],
+					[ 'User', 'Message', 'Subscriber' ],
+				],
+				all: [ 'User', 'Message', 'DM', 'Actions', 'Subscriber' ],
+				dependencies: [ "Link" ],
+				graph: [
+					[ 'Link', [ ] ],
+					[ 'Subscriber', [ 'User' ] ],
+					[ 'Message', [ 'Message', 'Link', 'Subscriber' ] ],
+					[ 'User', [ 'Message', 'User' ] ],
+					[ 'DM', [ 'User' ] ],
+					[ 'Actions', [ 'DM' ] ],
+					[ 'Product', [ ] ],
+					[ 'Cart', [ 'Product' ] ],
+				],
+			} ),
+		);
+	} );
+} );
+
+describe( "sortTypeAnalysisResult", ( ) =>
+{
+	it( "should sort properly", ( ) =>
+	{
+		const sorted = sortTypeAnalysisResult( {
+			all: [ ],
+			cycles: [ ],
+			dependencies: [ 'b', 'a' ],
+			entrypoints: [ ],
+			graph: [
+				[ 'x', [ 'a', 'c', 'b' ] ],
+				[ 'f', [ 'g', 'h' ] ],
+				[ 'g', [ 'h', 'f', 'g' ] ],
+			],
+		} );
+
+		expect( sorted ).toStrictEqual( {
+			all: [ ],
+			cycles: [ ],
+			dependencies: [ 'a', 'b' ],
+			entrypoints: [ ],
+			graph: [
+				[ 'f', [ 'g', 'h' ] ],
+				[ 'g', [ 'f', 'g', 'h' ] ],
+				[ 'x', [ 'a', 'b', 'c' ] ],
+			],
+		} );
+	} );
+} );

lib/index.ts

@@ -0,0 +1,65 @@
+import * as traverse from 'json-schema-traverse'
+import {
+	analyzeGraph,
+	sortAnalysisResult,
+	Edge,
+	Graph,
+	AnalysisResult,
+} from 'graph-cycles'
+
+
+function decodeRef( ref: string | undefined )
+{
+	if ( ref == null )
+		return undefined;
+
+	if ( ref.startsWith( "#/definitions/" ) )
+		return ref.slice( 14 );
+
+	return undefined;
+}
+
+interface TypeAnalysisResult extends AnalysisResult
+{
+	graph: Graph;
+}
+
+export function analyzeTypes( schema: traverse.SchemaObject )
+: TypeAnalysisResult
+{
+	const graph = Object
+		.keys( schema.definitions ?? { } )
+		.map( ( type ): Edge =>
+		{
+			const subSchema = schema.definitions[ type ];
+
+			const dependencies = new Set< string >( );
+
+			traverse( subSchema, ( schema: traverse.SchemaObject ) =>
+			{
+				const ref = decodeRef( schema.$ref );
+				if ( ref )
+					dependencies.add( ref );
+			} );
+
+			return [ type, [ ...dependencies ] ];
+		} );
+
+	return { ...analyzeGraph( graph ), graph };
+}
+
+export function sortTypeAnalysisResult( result: TypeAnalysisResult )
+: TypeAnalysisResult
+{
+	const { graph } = result;
+
+	const sortedGraph =
+		[ ...graph ]
+		.sort( ( a, b ) => a[ 0 ].localeCompare( b[ 0 ] ) )
+		.map( ( [ from, to ] ): Edge => [ from, [ ...to ].sort( ) ] );
+
+	return {
+		...sortAnalysisResult( result ),
+		graph: sortedGraph,
+	};
+}