Reference client kick-off

.gitignore

@@ -0,0 +1,4 @@
+node_modules
+.idea
+.vs
+bin

index.ts

@@ -0,0 +1 @@
+

karma.conf.js

@@ -0,0 +1,38 @@
+module.exports = function(config) {
+    config.set({
+        basePath: "",
+        frameworks: ["jasmine", "sinon", "jasmine-sinon", "source-map-support", "karma-typescript"],
+        files: [
+            { pattern: "src/**/*.ts", included: true },
+            { pattern: "testing/**/*.ts", included: true },
+            { pattern: "tests/**/*.spec.ts", included: true }
+        ],
+        exclude: [
+            "jsonld-request"
+        ],
+        preprocessors: {
+            "**/*.ts": ["karma-typescript"]
+        },
+        karmaTypescriptConfig: {
+            tsconfig: "tsconfig.json",
+            coverageOptions: {
+                instrumentation: false
+            },
+            bundlerOptions: {
+                entrypoints: /\.spec\.ts$/,
+                exclude: [
+                    "jsonld-request",
+                    "pkginfo"
+                ]
+            }
+        },
+        reporters: ["progress", "karma-typescript"],
+        port: 9876,
+        colors: true,
+        logLevel: config.LOG_INFO,
+        autoWatch: true,
+        browsers: ["Chrome"],
+        singleRun: false,
+        concurrency: Infinity
+    })
+};

package.json

@@ -0,0 +1,28 @@
+{
+    "name": "hydraclient.js",
+    "version": "0.0.1",
+    "scripts": {
+        "test": "node node_modules/karma/bin/karma start",
+        "test-once": "node node_modules/karma/bin/karma start --single-run"
+    },
+    "dependencies": {
+        "jsonld": "^0.4.12",
+        "typescript": "^2.3.3",
+        "whatwg-fetch": "^2.0.3"
+    },
+    "devDependencies": {
+        "@types/jasmine": "^2.5.47",
+        "@types/node": "^7.0.21",
+        "@types/sinon": "^2.2.2",
+        "jasmine": "^2.6.0",
+        "jasmine-sinon": "^0.4.0",
+        "karma": "^1.7.0",
+        "karma-chrome-launcher": "^2.1.1",
+        "karma-jasmine": "^1.1.0",
+        "karma-jasmine-sinon": "^1.0.4",
+        "karma-sinon": "^1.0.5",
+        "karma-source-map-support": "^1.2.0",
+        "karma-typescript": "^3.0.2",
+        "sinon": "^2.2.0"
+    }
+}

src/ApiDocumentation.ts

@@ -0,0 +1,30 @@
+import {IApiDocumentation} from "./DataModel/IApiDocumentation";
+import {IData} from "./DataModel/IData";
+import {IClass} from "./DataModel/IClass";
+import {IOperation} from "./DataModel/IOperation";
+import HydraClient from "./HydraClient";
+
+export default class ApiDocumentation implements IApiDocumentation
+{
+    public supportedClasses: Array<IClass>;
+    public supportedOperations: Array<IOperation>;
+    public client: HydraClient;
+    public entryPoint: string;
+
+    public async getEntryPoint(): Promise<IData>
+    {
+        let response = await window.fetch(this.entryPoint);
+        if (response.status !== 200)
+        {
+            throw new Error(HydraClient.invalidResponse + response.status);
+        }
+
+        let metadataProvider = this.client.getMetadataProvider(response);
+        if (!metadataProvider)
+        {
+            throw new Error(HydraClient.responseFormatNotSupported);
+        }
+
+        return await metadataProvider.parse(response, true);
+    }
+}

src/DataModel/IApiDocumentation.ts

@@ -0,0 +1,9 @@
+import {IMetadataDescription} from "./IMetadataDescription";
+import {IData} from "./IData";
+
+export interface IApiDocumentation extends IMetadataDescription
+{
+    entryPoint: string;
+
+    getEntryPoint(): Promise<IData>;
+}

src/DataModel/IClass.ts

@@ -0,0 +1,5 @@
+import {IResource} from "./IResource";
+
+export interface IClass extends IResource
+{
+}

src/DataModel/IData.ts

@@ -0,0 +1,6 @@
+import {IMetadata} from "./IMetadata";
+
+export interface IData extends Object
+{
+    metadata: Array<IMetadata>;
+}

src/DataModel/IMetadata.ts

@@ -0,0 +1,6 @@
+import HydraClient from "../HydraClient";
+
+export interface IMetadata
+{
+    client: HydraClient;
+}

src/DataModel/IMetadataDescription.ts

@@ -0,0 +1,11 @@
+import {IMetadata} from "./IMetadata";
+import {IClass} from "./IClass";
+import {IOperation} from "./IOperation";
+import HydraClient from "../HydraClient";
+
+export interface IMetadataDescription extends IMetadata
+{
+    supportedClasses: Array<IClass>;
+
+    supportedOperations: Array<IOperation>;
+}

src/DataModel/IMetadataProvider.ts

@@ -0,0 +1,30 @@
+import {IMetadataDescription} from "./IMetadataDescription";
+import "whatwg-fetch";
+import {IData} from "./IData";
+
+/**
+ * @interface Describes an abstract meta-data providing facility which translates from raw @link Response to an abstract data model.
+ */
+export interface IMetadataProvider
+{
+    /**
+     * Gets supported media types.
+     * @returns {Array<string>}
+     */
+    supportedMediaTypes: Array<string>;
+
+    /**
+     * Parses a given raw response.
+     * @param {Response} response Raw fetch response holding data to be parsed.
+     * @returns {Promise<IData>}
+     */
+    parse(response: Response): Promise<IData>;
+
+    /**
+     * Parses a given raw response.
+     * @param {Response} response Raw fetch response holding data to be parsed.
+     * @param {boolean} removeFromPayload Instructs whether to remove the metadata from the response's body or not.
+     * @returns {Promise<IData>}
+     */
+    parse(response: Response, removeFromPayload: boolean): Promise<IData>;
+}

src/DataModel/IOperation.ts

@@ -0,0 +1,6 @@
+import {IResource} from "./IResource";
+
+export interface IOperation extends IResource
+{
+
+}

src/DataModel/IResource.ts

@@ -0,0 +1,5 @@
+export interface IResource
+{
+    "@id": string;
+    "@type"?: Array<string>
+}

src/DataModel/JsonLd/JsonLdMetadataProvider.ts

@@ -0,0 +1,112 @@
+import HydraClient from "../../HydraClient";
+import {IMetadataProvider} from "../IMetadataProvider";
+import {IData} from "../IData";
+import {hydra} from "../../namespaces";
+const jsonLd = require("jsonld").promises;
+const context = require("./context.json");
+
+export default class JsonLdMetadataProvider implements IMetadataProvider
+{
+    private static _mediaTypes = ["application/json+ld"];
+    private static _id = 0;
+
+    static initialize()
+    {
+        HydraClient.registerMetadataProvider(new JsonLdMetadataProvider());
+    }
+
+    public get supportedMediaTypes(): Array<string>
+    {
+        return JsonLdMetadataProvider._mediaTypes;
+    }
+
+    public async parse(response: Response, removeFromPayload: boolean = false): Promise<IData>
+    {
+        let payload = await response.json();
+        let expanded = await jsonLd.flatten(payload);
+        let metadata = JsonLdMetadataProvider.parseMetadata(expanded, new Array<any>(), removeFromPayload);
+        let result = await jsonLd.frame(metadata, context, { embed: "@link" });
+        result = result["@graph"];
+        for (let index = result.length - 1; index >=0; index--)
+        {
+            if ((Object.keys(result[index]).length == 1) && (result[index]["@id"]))
+            {
+                result.splice(index, 1);
+            }
+        }
+
+        Object.defineProperty(expanded, "metadata", { value: result, enumerable: false });
+        return expanded;
+    }
+
+    private static parseMetadata(payload: any, result: Array<any> & { [key: string]: any }, removeFromPayload: boolean = false): any
+    {
+        if (payload instanceof Array)
+        {
+            return JsonLdMetadataProvider.parseArray(payload, result, removeFromPayload);
+        }
+
+        if (payload["@graph"])
+        {
+            return JsonLdMetadataProvider.parseMetadata(payload["@graph"], result, removeFromPayload);
+        }
+
+        return JsonLdMetadataProvider.parseResource(payload, result, removeFromPayload);
+    }
+
+    private static parseArray(payload: any, result: Array<any> & { [key: string]: any }, removeFromPayload: boolean = false)
+    {
+        let toBeRemoved = new Array<any>();
+        for (let resource of payload)
+        {
+            if (resource["@type"] && resource["@type"].every(item => item.indexOf(hydra.namespace) === 0))
+            {
+                Object.defineProperty(result, resource["@id"] || "_:bnode" + (++JsonLdMetadataProvider._id), { enumerable: false, value: resource });
+                result.push(resource);
+                if (removeFromPayload)
+                {
+                    toBeRemoved.push(resource);
+                }
+            }
+            else
+            {
+                JsonLdMetadataProvider.parseMetadata(resource, result, removeFromPayload);
+            }
+        }
+
+        toBeRemoved.forEach(item => payload.splice(payload.indexOf(item), 1));
+        return result;
+    }
+
+    private static parseResource(resource: any, result: Array<any> & { [key: string]: any }, removeFromPayload: boolean): any
+    {
+        let targetResource;
+        if ((resource["@id"]) && (targetResource = result[resource["@id"]]))
+        {
+            targetResource["@id"] = resource["@id"];
+        }
+
+        if (!targetResource)
+        {
+            targetResource = {};
+            Object.defineProperty(result, "_:bnode" + (++JsonLdMetadataProvider._id), { enumerable: false, value: targetResource });
+            result.push(targetResource);
+        }
+
+        for (let property of Object.keys(resource).filter(property => property.charAt(0) !== "@"))
+        {
+            if (property.indexOf(hydra.namespace) === 0)
+            {
+                targetResource[property] = resource[property];
+                if (removeFromPayload)
+                {
+                    delete resource[property];
+                }
+            }
+        }
+
+        return result;
+    }
+}
+
+JsonLdMetadataProvider.initialize();

src/DataModel/JsonLd/context.json

@@ -0,0 +1,24 @@
+{
+    "@context": {
+        "@vocab": "http://www.w3.org/ns/hydra/core#",
+        "hydra": "http://www.w3.org/ns/hydra/core#",
+        "operations": "hydra:operation",
+        "supportedClasses": {
+            "@id": "hydra:supportedClass",
+            "@container": "@set"
+        },
+        "entryPoint": "hydra:entrypoint",
+        "supportedOperations": {
+            "@id": "hydra:supportedOperation",
+            "@container": "@set"
+        },
+        "supportedProperties": {
+            "@id": "hydra:supportedProperty",
+            "@container": "@set"
+        },
+        "members": {
+            "@id": "hydra:member",
+            "@container": "@set"
+        }
+    }
+}