json-schema-library 11.0.5 → 11.2.0

package/src/keywords/unevaluatedProperties.ts

@@ -1,26 +1,43 @@
 import { isObject } from "../utils/isObject";
-import { SchemaNode } from "../types";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { Keyword, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { validateNode } from "../validateNode";
 import { isPropertyEvaluated } from "../isPropertyEvaluated";
 
+const KEYWORD = "unevaluatedProperties";
+
 export const unevaluatedPropertiesKeyword: Keyword = {
-    id: "unevaluatedProperties",
-    keyword: "unevaluatedProperties",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseUnevaluatedProperties,
-    addValidate: ({ schema }) => schema.unevaluatedProperties != null,
+    addValidate: ({ schema }) => schema[KEYWORD] != null, // currently we do not store boolean schema
     validate: validateUnevaluatedProperties
 };
 
 export function parseUnevaluatedProperties(node: SchemaNode) {
-    if (!isObject(node.schema.unevaluatedProperties)) {
+    const unevaluatedProperties = node.schema[KEYWORD];
+    if (unevaluatedProperties == null) {
+        return;
+    }
+    if (!(isJsonSchema(unevaluatedProperties) || isBooleanSchema(unevaluatedProperties))) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: unevaluatedProperties,
+            message: `Keyword '${KEYWORD}' must be a valid JSON Schema - received '${typeof unevaluatedProperties}'`
+        });
+    }
+
+    if (isBooleanSchema(unevaluatedProperties)) {
         return;
     }
+
     node.unevaluatedProperties = node.compileSchema(
         node.schema.unevaluatedProperties,
-        `${node.evaluationPath}/unevaluatedProperties`,
-        `${node.schemaLocation}/unevaluatedProperties`
+        `${node.evaluationPath}/${KEYWORD}`,
+        `${node.schemaLocation}/${KEYWORD}`
     );
+    return node.unevaluatedProperties.schemaValidation;
 }
 
 // @todo we should use collected annotation to evaluated unevaluate properties

package/src/keywords/uniqueItems.ts

@@ -1,14 +1,33 @@
-import { JsonError } from "../types";
+import { JsonError, SchemaNode } from "../types";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
 import deepEqual from "fast-deep-equal";
 
+const KEYWORD = "uniqueItems";
+
 export const uniqueItemsKeyword: Keyword = {
-    id: "uniqueItems",
-    keyword: "uniqueItems",
-    addValidate: ({ schema }) => schema.uniqueItems === true,
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseUniqueItems,
+    addValidate: ({ schema }) => schema[KEYWORD] === true,
     validate: validateUniqueItems
 };
 
+function parseUniqueItems(node: SchemaNode) {
+    const uniqueItems = node.schema[KEYWORD];
+    if (uniqueItems == null || uniqueItems === false) {
+        return;
+    }
+    if (typeof uniqueItems !== "boolean") {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: uniqueItems,
+            message: `Keyword '${KEYWORD}' must be a boolean - received ${typeof uniqueItems}`
+        });
+    }
+    node.uniqueItems = true;
+}
+
 function validateUniqueItems({ node, data, pointer }: JsonSchemaValidatorParams) {
     if (!Array.isArray(data)) {
         return undefined;

package/src/mergeNode.ts

@@ -37,9 +37,12 @@ function mergeObjects(a?: Record<string, SchemaNode>, b?: Record<string, SchemaN
     return object;
 }
 
-// function mergeArray<T = unknown[]>(a?: T[], b?: T[]) {
-//     return a || b ? [...(a ?? []), ...(b ?? [])] : undefined;
-// }
+function combineArrays<T>(a?: T[], b?: T[]): T[] | undefined {
+    if (a == null || b == null) {
+        return b || a;
+    }
+    return a.concat(b).filter((value, index, list) => list.indexOf(value) === index);
+}
 
 function mergePatternProperties(a?: SchemaNode["patternProperties"], b?: SchemaNode["patternProperties"]) {
     if (a == null || b == null) {
@@ -92,6 +95,7 @@ export function mergeNode(a?: SchemaNode, b?: SchemaNode, ...omit: string[]): Sc
 
         additionalProperties: mergeNode(a.additionalProperties, b.additionalProperties),
         contains: mergeNode(a.contains, b.contains),
+        enum: combineArrays(a.enum, b.enum),
         if: mergeNode(a.if, b.if),
         then: mergeNode(a.then, b.then),
         else: mergeNode(a.else, b.else),
@@ -101,7 +105,8 @@ export function mergeNode(a?: SchemaNode, b?: SchemaNode, ...omit: string[]): Sc
         unevaluatedItems: mergeNode(a.unevaluatedItems, b.unevaluatedItems),
         $defs: mergeObjects(a.$defs, b.$defs),
         patternProperties: mergePatternProperties(a.patternProperties, b.patternProperties),
-        properties: mergeObjects(a.properties, b.properties)
+        properties: mergeObjects(a.properties, b.properties),
+        required: combineArrays(a.required, b.required)
     };
 
     // this removes any function that has no keyword associated on schema

package/src/methods/getData.ts

@@ -159,7 +159,7 @@ export function getData(node: SchemaNode, data?: unknown, opts?: TemplateOptions
         return defaultData;
     }
 
-    if (resolvedNode && resolvedNode !== currentNode) {
+    if (isSchemaNode(resolvedNode)) {
         defaultData = resolvedNode.getData(defaultData, opts) ?? defaultData;
         currentNode = resolvedNode;
     }

package/src/settings.ts

@@ -14,7 +14,8 @@ export default {
         "dependentRequired",
         "definitions",
         "dependencies",
-        "patternProperties"
+        "patternProperties",
+        "propertyDependencies"
     ],
     REGEX_FLAGS: "u"
 };

package/src/types.ts

@@ -67,5 +67,5 @@ export function isJsonError(error: unknown): error is JsonError {
 }
 
 export function isNumber(value: unknown): value is number {
-    return isNaN(value as number) === false;
+    return typeof value === "number";
 }

package/src/utils/isListOfStrings.ts

@@ -0,0 +1,3 @@
+export function isListOfStrings(v: unknown): v is string[] {
+    return Array.isArray(v) && v.find((item) => typeof item !== "string") == null;
+}

package/src/validate.test.ts

@@ -8,7 +8,6 @@ describe("compileSchema : validate", () => {
     // note: boolean schema is already thoroughly tested by spec
     describe("boolean schema", () => {
         it("should fail if root schema is false", () => {
-            // @ts-expect-error boolean typ unsupported
             const { errors } = compileSchema(false).validate("anything");
             assert.deepEqual(errors.length, 1);
         });
@@ -23,7 +22,6 @@ describe("compileSchema : validate", () => {
             assert.deepEqual(errors.length, 1);
         });
         it("should succeed if root schema is true", () => {
-            // @ts-expect-error boolean typ unsupported
             const { errors } = compileSchema(true).validate("anything");
             assert.deepEqual(errors.length, 0);
         });

package/src/validateNode.ts

@@ -1,8 +1,11 @@
-import { BooleanSchema, JsonSchema, SchemaNode } from "./types";
-import { ValidationPath, ValidationReturnType } from "./Keyword";
+import { BooleanSchema, isJsonError, JsonSchema, SchemaNode } from "./types";
+import { SchemaNodeWithRequired, ValidationPath, ValidationReturnType } from "./Keyword";
 import sanitizeErrors from "./utils/sanitizeErrors";
 
 export function validateNode(node: SchemaNode, data: unknown, pointer: string, path: ValidationPath) {
+    if (isJsonError(node)) {
+        return [node];
+    }
     path.push({ pointer, node });
     const schema = node.schema as BooleanSchema | JsonSchema;
     if (schema === true) {
@@ -19,7 +22,7 @@ export function validateNode(node: SchemaNode, data: unknown, pointer: string, p
     }
     const errors: ValidationReturnType = [];
     for (const validate of node.validators) {
-        const result = validate({ node, data, pointer, path });
+        const result = validate({ node: node as SchemaNodeWithRequired<keyof SchemaNode>, data, pointer, path });
         if (Array.isArray(result)) {
             errors.push(...result);
         } else if (result) {

package/src/validateSchema.test.ts

@@ -0,0 +1,312 @@
+import { compileSchema } from "./compileSchema";
+import { strict as assert } from "assert";
+import { extendDraft } from "./Draft";
+import { draft2020 } from "./draft2020";
+import { propertyDependenciesKeyword } from "./keywords/propertyDependencies";
+import { draft07 } from "./draft07";
+
+const withAdditionalKeywords = {
+    drafts: [
+        extendDraft(draft2020, {
+            keywords: [propertyDependenciesKeyword]
+        })
+    ]
+};
+
+describe("validateSchema", () => {
+    it("should error if `$defs` is not an object", () => {
+        const { schemaErrors } = compileSchema({ $defs: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should throw an error if schema is invalid and option 'throwOnInvalidSchema = true'", () => {
+        assert.throws(() => {
+            compileSchema({ $defs: true }, { throwOnInvalidSchema: true });
+        });
+    });
+    it("should error for missing `$ref` target in $defs", () => {
+        const { schemaErrors } = compileSchema({
+            type: "object",
+            properties: {
+                invalid: { $ref: "#/$defs/invalid" }
+            }
+        });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/properties/invalid/$ref");
+        assert.equal(schemaErrors[0].data.value, "#/$defs/invalid");
+    });
+    it("should error if `additionalProperties` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ additionalProperties: 999 });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `allOf` is not a an array", () => {
+        const { schemaErrors } = compileSchema({ allOf: {} });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `allOf schema` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ allOf: [999] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `anyOf` is not a an array", () => {
+        const { schemaErrors } = compileSchema({ anyOf: {} });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `anyOf schema` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ anyOf: [999] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    // any const is valid: https://json-schema.org/draft/2020-12/json-schema-validation#name-const
+    it("should error if `contains` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ contains: [] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `dependencies` is not a an object", () => {
+        const { schemaErrors } = compileSchema({ dependencies: [] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `dependentRequired` is not a an object", () => {
+        const { schemaErrors } = compileSchema({ dependentRequired: [] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `dependentRequired` is not a an object with a list of strings", () => {
+        const { schemaErrors } = compileSchema({
+            dependentRequired: {
+                property: ["title", true]
+            }
+        });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `dependentSchemas` is not a an object containing schemata", () => {
+        const { schemaErrors } = compileSchema({
+            dependentSchemas: {
+                valid: { type: "string" },
+                stillValid: true,
+                invalid: 999
+            }
+        });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/dependentSchemas/invalid");
+    });
+    it("should error if `deprecated` is not a a boolean", () => {
+        const { schemaErrors } = compileSchema({ deprecated: {} });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `enum` is not an array", () => {
+        const { schemaErrors } = compileSchema({ type: "string", enum: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `exclusiveMaximum` is not a number", () => {
+        const { schemaErrors } = compileSchema({ exclusiveMaximum: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `exclusiveMinimum` is not a number", () => {
+        const { schemaErrors } = compileSchema({ exclusiveMinimum: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `format` is not a string", () => {
+        const { schemaErrors } = compileSchema({ format: {} });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `if` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ if: 999, then: false, else: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `then` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ if: {}, then: [], else: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `else` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ if: {}, then: false, else: 999 });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `items` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ items: [] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `maximum` is not a number", () => {
+        const { schemaErrors } = compileSchema({ maximum: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `maxItems` is not a number", () => {
+        const { schemaErrors } = compileSchema({ maxItems: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `maxLength` is not a number", () => {
+        const { schemaErrors } = compileSchema({ maxLength: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `maxProperties` is not a number", () => {
+        const { schemaErrors } = compileSchema({ maxProperties: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `minimum` is not a number", () => {
+        const { schemaErrors } = compileSchema({ minimum: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `minItems` is not a number", () => {
+        const { schemaErrors } = compileSchema({ minItems: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `minLength` is not a number", () => {
+        const { schemaErrors } = compileSchema({ minLength: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `minProperties` is not a number", () => {
+        const { schemaErrors } = compileSchema({ minProperties: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `multipleOf` is not a number", () => {
+        const { schemaErrors } = compileSchema({ multipleOf: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `not` is not a JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ not: [] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `oneOf` is not a an array", () => {
+        const { schemaErrors } = compileSchema({ oneOf: {} });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `oneOf schema` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ oneOf: [999] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `pattern` is not a string", () => {
+        const { schemaErrors } = compileSchema({ type: "string", pattern: true });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `pattern` is an invalid regexp", () => {
+        const { schemaErrors } = compileSchema({ type: "string", pattern: "(" });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `properties` is not an object", () => {
+        const { schemaErrors } = compileSchema({ type: "object", properties: 999 });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `properties[string]` is not a JSON Schema", () => {
+        const { schemaErrors } = compileSchema({
+            type: "object",
+            properties: {
+                valid: { type: "string" },
+                alsoValid: false,
+                invalid: 999
+            }
+        });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/properties/invalid");
+    });
+    it("should error if `propertyDependencies` is not an object", () => {
+        const { schemaErrors } = compileSchema({ propertyDependencies: true }, withAdditionalKeywords);
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `propertyDependencies[string]` is not an object", () => {
+        const { schemaErrors } = compileSchema({ propertyDependencies: { invalid: true } }, withAdditionalKeywords);
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `propertyDependencies[string][string]` is not JSON Schema", () => {
+        const { schemaErrors } = compileSchema(
+            { propertyDependencies: { valid: { invalid: 999 } } },
+            withAdditionalKeywords
+        );
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `propertyNames` is not a JSON Schema type", () => {
+        const { schemaErrors } = compileSchema({ propertyNames: "error" });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/propertyNames");
+    });
+    it("should error if `required` is not a string[]", () => {
+        const { schemaErrors } = compileSchema({ type: "object", required: [123, "valid"] });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/required");
+    });
+    it("should error if `type` is not a JSON Schema type", () => {
+        const { schemaErrors } = compileSchema({ type: "error" });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/type");
+    });
+    it("should error if `type` is not a valid JSON Schema type format", () => {
+        const { schemaErrors } = compileSchema({ type: {} });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/type");
+    });
+    it("should error if `type` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ type: "error" });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/type");
+    });
+    it("should error if `unevaluatedItems` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ unevaluatedItems: [] });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/unevaluatedItems");
+    });
+    it("should error if `unevaluatedProperties` is not a valid JSON Schema", () => {
+        const { schemaErrors } = compileSchema({ unevaluatedProperties: 999 });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/unevaluatedProperties");
+    });
+    it("should error if `uniqueItems` is not a boolean", () => {
+        const { schemaErrors } = compileSchema({ uniqueItems: {} });
+        assert.equal(schemaErrors?.length, 1);
+        assert.equal(schemaErrors[0].data.pointer, "#/uniqueItems");
+    });
+
+    describe("annotations", () => {
+        it("should return unknown keywords as annotation", () => {
+            const { schemaAnnotations } = compileSchema(
+                {
+                    properties: {
+                        headline: {
+                            options: {},
+                            type: "string"
+                        }
+                    }
+                },
+                { withSchemaAnnotations: true }
+            );
+            assert.equal(schemaAnnotations.length, 1);
+            assert.equal(schemaAnnotations[0].data.pointer, "#/properties/headline/options");
+        });
+        it("should return not unknown keywords starting with 'x-'", () => {
+            const { schemaAnnotations } = compileSchema(
+                {
+                    properties: {
+                        headline: {
+                            "x-options": {},
+                            type: "string"
+                        }
+                    }
+                },
+                { withSchemaAnnotations: true }
+            );
+            assert.equal(schemaAnnotations.length, 0);
+        });
+        it("should return removed keywords from old drafts as annotation", () => {
+            const { schemaAnnotations } = compileSchema(
+                {
+                    properties: {
+                        headline: {
+                            additionalItems: true
+                        }
+                    }
+                },
+                { withSchemaAnnotations: true }
+            );
+            assert.equal(schemaAnnotations.length, 1);
+            assert.equal(schemaAnnotations[0].data.pointer, "#/properties/headline/additionalItems");
+        });
+        it("should return new keywords in old drafts as annotation", () => {
+            const { schemaAnnotations } = compileSchema(
+                {
+                    properties: {
+                        headline: {
+                            prefixItems: []
+                        }
+                    }
+                },
+                { drafts: [draft07], withSchemaAnnotations: true }
+            );
+            assert.equal(schemaAnnotations.length, 1);
+            assert.equal(schemaAnnotations[0].data.pointer, "#/properties/headline/prefixItems");
+        });
+    });
+});

package/tsconfig.json

@@ -7,10 +7,17 @@
         "module": "ESNext",
         "resolveJsonModule": true,
         "allowSyntheticDefaultImports": true,
-        "moduleResolution": "node",
+        "moduleResolution": "bundler",
         "lib": ["DOM", "ES2018"],
-        "exactOptionalPropertyTypes": true
+        "exactOptionalPropertyTypes": true,
+        "baseUrl": ".",
+        "paths": {
+            "json-schema-library": ["./index.ts"],
+            "json-schema-library/remotes": ["./remotes/index.ts"],
+            "json-schema-library/package.json": ["./package.json"]
+        },
+        "types": ["node", "mocha"]
     },
-    "exclude": ["src/**/*.test.ts"],
-    "include": ["index.ts", "src/**/*"]
+    "exclude": ["src/**/*.test.ts", "src/**/*.spec.ts", "bowtie/**/*.test.ts"],
+    "include": ["index.ts", "src/**/*", "remotes/**/*", "bowtie/**/*"]
 }

package/tsconfig.test.json

@@ -5,11 +5,18 @@
         "incremental": false /* Enable incremental compilation */,
         "target": "ESNEXT" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */,
         "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
+        "moduleResolution": "node10",
         "sourceMap": false /* Generates corresponding '.map' file. */,
         "strict": false /* Enable all strict type-checking options. */,
         "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
-        "types": ["mocha", "node"]
+        "types": ["mocha", "node"],
+        "baseUrl": ".",
+        "paths": {
+            "json-schema-library": ["./index.ts"],
+            "json-schema-library/remotes": ["./remotes/index.ts"],
+            "json-schema-library/package.json": ["./package.json"]
+        }
     },
     "exclude": [],
-    "include": ["src/**/*.test.ts"]
+    "include": ["src/**/*.test.ts", "bowtie/**/*.test.ts"]
 }

package/tsdown.config.ts

@@ -2,7 +2,7 @@ import { defineConfig } from "tsdown";
 
 export default defineConfig({
     dts: true,
-    entry: ["./index.ts"],
+    entry: ["./index.ts", "./remotes/index.ts"],
     exports: true,
     globalName: "jlib"
 });

package/Dockerfile

@@ -1,6 +0,0 @@
-FROM node:23-alpine
-COPY . /usr/app
-WORKDIR /usr/app
-#ENV NODE_ENV=production
-#RUN npm install --omit=dev
-CMD ["node", "bowtie_jlib.js"]