@digicatapult/dtdl-parser 0.0.3

package/interop/DtdlErr.d.ts

@@ -0,0 +1,26 @@
+export type ModelingException = ParsingException | ResolutionException
+
+export interface ParsingException {
+  ExceptionKind: 'Parsing'
+  Errors: ParsingError[]
+}
+
+export interface ParsingError {
+  PrimaryID?: string
+  SecondaryID?: string
+  Property?: string
+  AuxProperty?: string
+  Type?: string
+  Value?: string
+  Restriction?: string
+  Transformation?: string
+  Violations?: string[]
+  Cause: string
+  Action: string
+  ValidationID: string
+}
+
+export interface ResolutionException {
+  ExceptionKind: 'Resolution'
+  UndefinedIdentifiers: string[]
+}

package/interop/DtdlOm.d.ts

@@ -0,0 +1,372 @@
+export type DtdlObjectModel = { [entityId: string]: EntityType }
+
+export interface ArrayInfo extends ComplexSchemaInfo {
+  EntityKind: 'Array'
+  elementSchema: string
+}
+
+export type ArrayType = ArrayInfo
+
+export interface BooleanInfo extends PrimitiveSchemaInfo {
+  EntityKind: 'Boolean'
+}
+
+export type BooleanType = BooleanInfo
+
+export interface CommandInfo extends ContentInfo {
+  EntityKind: 'Command'
+  commandType?: string
+  request?: string
+  response?: string
+}
+
+export type CommandType = CommandInfo
+
+export interface CommandPayloadInfo extends SchemaFieldInfo {
+  EntityKind: 'CommandPayload' | 'CommandRequest' | 'CommandResponse'
+}
+
+export type CommandPayloadType = CommandPayloadInfo | CommandRequestType | CommandResponseType
+
+export interface CommandRequestInfo extends CommandPayloadInfo {
+  EntityKind: 'CommandRequest'
+}
+
+export type CommandRequestType = CommandRequestInfo
+
+export interface CommandResponseInfo extends CommandPayloadInfo {
+  EntityKind: 'CommandResponse'
+}
+
+export type CommandResponseType = CommandResponseInfo
+
+export interface CommandTypeInfo extends EntityInfo {
+  EntityKind: 'CommandType'
+}
+
+export type CommandTypeType = CommandTypeInfo
+
+export interface ComplexSchemaInfo extends SchemaInfo {
+  EntityKind: 'Array' | 'Enum' | 'Map' | 'Object'
+}
+
+export type ComplexSchemaType = ComplexSchemaInfo | ArrayType | EnumType | MapType | ObjectType
+
+export interface ComponentInfo extends ContentInfo {
+  EntityKind: 'Component'
+  schema: string
+}
+
+export type ComponentType = ComponentInfo
+
+export interface ContentInfo extends NamedEntityInfo {
+  EntityKind: 'Command' | 'Component' | 'Property' | 'Relationship' | 'Telemetry'
+}
+
+export type ContentType = ContentInfo | CommandType | ComponentType | PropertyType | RelationshipType | TelemetryType
+
+export interface DateInfo extends TemporalSchemaInfo {
+  EntityKind: 'Date'
+}
+
+export type DateType = DateInfo
+
+export interface DateTimeInfo extends TemporalSchemaInfo {
+  EntityKind: 'DateTime'
+}
+
+export type DateTimeType = DateTimeInfo
+
+export interface DoubleInfo extends NumericSchemaInfo {
+  EntityKind: 'Double'
+}
+
+export type DoubleType = DoubleInfo
+
+export interface DurationInfo extends TemporalSchemaInfo {
+  EntityKind: 'Duration'
+}
+
+export type DurationType = DurationInfo
+
+export interface EntityInfo {
+  EntityKind:
+    | 'Array'
+    | 'Boolean'
+    | 'Command'
+    | 'CommandPayload'
+    | 'CommandType'
+    | 'Component'
+    | 'Date'
+    | 'DateTime'
+    | 'Double'
+    | 'Duration'
+    | 'Enum'
+    | 'EnumValue'
+    | 'Field'
+    | 'Float'
+    | 'Integer'
+    | 'Interface'
+    | 'Long'
+    | 'Map'
+    | 'MapKey'
+    | 'MapValue'
+    | 'Object'
+    | 'Property'
+    | 'Relationship'
+    | 'String'
+    | 'Telemetry'
+    | 'Time'
+    | 'CommandRequest'
+    | 'CommandResponse'
+    | 'Unit'
+    | 'UnitAttribute'
+    | 'LatentType'
+    | 'NamedLatentType'
+  SupplementalTypes: string[]
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  SupplementalProperties: { [property: string]: any }
+  UndefinedTypes: string[]
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  UndefinedProperties: { [property: string]: any }
+  ClassId: string
+  comment?: string
+  description: { [languageCode: string]: string }
+  displayName: { [languageCode: string]: string }
+  languageMajorVersion: number
+  Id: string
+  ChildOf?: string
+  DefinedIn?: string
+}
+
+export type EntityType =
+  | EntityInfo
+  | CommandTypeType
+  | InterfaceType
+  | LatentTypeType
+  | NamedEntityType
+  | SchemaType
+  | UnitType
+
+export interface EnumInfo extends ComplexSchemaInfo {
+  EntityKind: 'Enum'
+  enumValues: string[]
+  valueSchema: string
+}
+
+export type EnumType = EnumInfo
+
+export interface EnumValueInfo extends NamedEntityInfo {
+  EntityKind: 'EnumValue'
+  enumValue: string | number | boolean
+}
+
+export type EnumValueType = EnumValueInfo
+
+export interface FieldInfo extends SchemaFieldInfo {
+  EntityKind: 'Field'
+}
+
+export type FieldType = FieldInfo
+
+export interface FloatInfo extends NumericSchemaInfo {
+  EntityKind: 'Float'
+}
+
+export type FloatType = FloatInfo
+
+export interface IntegerInfo extends NumericSchemaInfo {
+  EntityKind: 'Integer'
+}
+
+export type IntegerType = IntegerInfo
+
+export interface InterfaceInfo extends EntityInfo {
+  EntityKind: 'Interface'
+  contents: { [name: string]: string }
+  commands: { [name: string]: string }
+  components: { [name: string]: string }
+  properties: { [name: string]: string }
+  relationships: { [name: string]: string }
+  telemetries: { [name: string]: string }
+  extends: string[]
+  extendedBy: string[]
+  schemas: string[]
+}
+
+export type InterfaceType = InterfaceInfo
+
+export interface LatentTypeInfo extends EntityInfo {
+  EntityKind: 'LatentType'
+}
+
+export type LatentTypeType = LatentTypeInfo
+
+export interface LongInfo extends NumericSchemaInfo {
+  EntityKind: 'Long'
+}
+
+export type LongType = LongInfo
+
+export interface MapInfo extends ComplexSchemaInfo {
+  EntityKind: 'Map'
+  mapKey: string
+  mapValue: string
+}
+
+export type MapType = MapInfo
+
+export interface MapKeyInfo extends NamedEntityInfo {
+  EntityKind: 'MapKey'
+  schema: string
+}
+
+export type MapKeyType = MapKeyInfo
+
+export interface MapValueInfo extends SchemaFieldInfo {
+  EntityKind: 'MapValue'
+}
+
+export type MapValueType = MapValueInfo
+
+export interface NamedEntityInfo extends EntityInfo {
+  EntityKind:
+    | 'Command'
+    | 'CommandPayload'
+    | 'Component'
+    | 'EnumValue'
+    | 'Field'
+    | 'MapKey'
+    | 'MapValue'
+    | 'Property'
+    | 'Relationship'
+    | 'Telemetry'
+    | 'CommandRequest'
+    | 'CommandResponse'
+    | 'UnitAttribute'
+    | 'NamedLatentType'
+  name: string
+}
+
+export type NamedEntityType =
+  | NamedEntityInfo
+  | ContentType
+  | EnumValueType
+  | MapKeyType
+  | NamedLatentTypeType
+  | SchemaFieldType
+  | UnitAttributeType
+
+export interface NamedLatentTypeInfo extends NamedEntityInfo {
+  EntityKind: 'NamedLatentType'
+}
+
+export type NamedLatentTypeType = NamedLatentTypeInfo
+
+export interface NumericSchemaInfo extends PrimitiveSchemaInfo {
+  EntityKind: 'Double' | 'Float' | 'Integer' | 'Long'
+}
+
+export type NumericSchemaType = NumericSchemaInfo | DoubleType | FloatType | IntegerType | LongType
+
+export interface ObjectInfo extends ComplexSchemaInfo {
+  EntityKind: 'Object'
+  fields: string[]
+}
+
+export type ObjectType = ObjectInfo
+
+export interface PrimitiveSchemaInfo extends SchemaInfo {
+  EntityKind: 'Boolean' | 'Date' | 'DateTime' | 'Double' | 'Duration' | 'Float' | 'Integer' | 'Long' | 'String' | 'Time'
+}
+
+export type PrimitiveSchemaType =
+  | PrimitiveSchemaInfo
+  | BooleanType
+  | NumericSchemaType
+  | StringType
+  | TemporalSchemaType
+
+export interface PropertyInfo extends ContentInfo {
+  EntityKind: 'Property'
+  schema: string
+  writable: boolean
+}
+
+export type PropertyType = PropertyInfo
+
+export interface RelationshipInfo extends ContentInfo {
+  EntityKind: 'Relationship'
+  maxMultiplicity?: number
+  minMultiplicity?: number
+  properties: string[]
+  target?: string
+  writable: boolean
+}
+
+export type RelationshipType = RelationshipInfo
+
+export interface SchemaInfo extends EntityInfo {
+  EntityKind:
+    | 'Array'
+    | 'Boolean'
+    | 'Date'
+    | 'DateTime'
+    | 'Double'
+    | 'Duration'
+    | 'Enum'
+    | 'Float'
+    | 'Integer'
+    | 'Long'
+    | 'Map'
+    | 'Object'
+    | 'String'
+    | 'Time'
+}
+
+export type SchemaType = SchemaInfo | ComplexSchemaType | PrimitiveSchemaType
+
+export interface SchemaFieldInfo extends NamedEntityInfo {
+  EntityKind: 'CommandPayload' | 'Field' | 'MapValue' | 'CommandRequest' | 'CommandResponse'
+  schema: string
+}
+
+export type SchemaFieldType = SchemaFieldInfo | CommandPayloadType | FieldType | MapValueType
+
+export interface StringInfo extends PrimitiveSchemaInfo {
+  EntityKind: 'String'
+}
+
+export type StringType = StringInfo
+
+export interface TelemetryInfo extends ContentInfo {
+  EntityKind: 'Telemetry'
+  schema: string
+}
+
+export type TelemetryType = TelemetryInfo
+
+export interface TemporalSchemaInfo extends PrimitiveSchemaInfo {
+  EntityKind: 'Date' | 'DateTime' | 'Duration' | 'Time'
+}
+
+export type TemporalSchemaType = TemporalSchemaInfo | DateType | DateTimeType | DurationType | TimeType
+
+export interface TimeInfo extends TemporalSchemaInfo {
+  EntityKind: 'Time'
+}
+
+export type TimeType = TimeInfo
+
+export interface UnitInfo extends EntityInfo {
+  EntityKind: 'Unit'
+  symbol?: string
+}
+
+export type UnitType = UnitInfo
+
+export interface UnitAttributeInfo extends NamedEntityInfo {
+  EntityKind: 'UnitAttribute'
+}
+
+export type UnitAttributeType = UnitAttributeInfo

package/interop/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Digital Twin Consortium and contributors.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/interop/ModelParserInterop.cs

@@ -0,0 +1,19 @@
+using DTDLParser;
+using System;
+using System.Runtime.InteropServices.JavaScript;
+using System.Runtime.Versioning;
+
+namespace DtdlParserJSInterop;
+
+[SupportedOSPlatform("browser")]
+public partial class ModelParserInterop
+{
+    public static void Main() => Console.WriteLine("dotnet loaded");
+
+    [JSExport]
+    public static string ParserVersion() => typeof(ModelParser).Assembly.FullName;
+
+    [JSExport]
+    public static string Parse(string dtdl) => new ModelParser().ParseToJson(dtdl);
+
+}

package/interop/README.md

@@ -0,0 +1 @@
+This directory modifies code from `DTDLParser for .NET`, licensed under an [MIT License](./LICENSE). You can find the original project [here](https://github.com/digitaltwinconsortium/DTDLParser).

package/interop/modelParser.js

@@ -0,0 +1,11 @@
+import { dotnet } from './_framework/dotnet.js'
+
+const { getAssemblyExports, getConfig } = await dotnet.withDiagnosticTracing(false).create()
+
+const config = getConfig()
+const assemblyExports = await getAssemblyExports(config.mainAssemblyName)
+
+const parserVersion = () => assemblyExports.DtdlParserJSInterop.ModelParserInterop.ParserVersion()
+const parse = (dtdl) => assemblyExports.DtdlParserJSInterop.ModelParserInterop.Parse(dtdl)
+
+export { parse, parserVersion }

package/interop/runtimeconfig.template.json

@@ -0,0 +1,11 @@
+{
+  "wasmHostProperties": {
+    "perHostConfig": [
+      {
+        "name": "node",
+        "js-path": "modelParser.js",
+        "host": "nodejs"
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@digicatapult/dtdl-parser",
+  "version": "0.0.3",
+  "description": "JS tool to parse DTDL defined Ontologies",
+  "main": "src/index.ts",
+  "type": "module",
+  "scripts": {
+    "test": "NODE_ENV=test ./node_modules/.bin/mocha --config ./test/mocharc.json ./src/**/*.test.ts",
+    "build": "npx swc ./src ./package.json -d ./build --copy-files",
+    "clean": "rimraf -rf ./build",
+    "lint": "eslint .",
+    "depcheck": "depcheck"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/digicatapult/dtdl-parser.git"
+  },
+  "keywords": [
+    "dtdl",
+    "digital",
+    "twins",
+    "parsing",
+    "tool"
+  ],
+  "author": "Digital Catapult",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/digicatapult/dtdl-parser/issues"
+  },
+  "homepage": "https://github.com/digicatapult/dtdl-parser#readme",
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.12.0",
+    "@swc-node/register": "^1.10.9",
+    "@swc/cli": "^0.4.1-nightly.20240914",
+    "@swc/core": "^1.7.35",
+    "@types/chai": "^5.0.0",
+    "@types/mocha": "^10.0.9",
+    "@types/node": "^22.7.5",
+    "@typescript-eslint/eslint-plugin": "^8.8.1",
+    "@typescript-eslint/parser": "^8.8.1",
+    "chai": "^5.1.1",
+    "depcheck": "^1.4.7",
+    "eslint": "^9.12.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "globals": "^15.11.0",
+    "mocha": "^10.7.3",
+    "prettier": "^3.3.3",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.6.3"
+  },
+  "engines": {
+    "node": ">= 20"
+  }
+}

package/src/__tests__/fixtures/empty.json

@@ -0,0 +1 @@
+{}

package/src/__tests__/fixtures/nested/nested.json

@@ -0,0 +1 @@
+{}

package/src/__tests__/index.test.ts

@@ -0,0 +1,119 @@
+import { expect } from 'chai'
+import { describe, it } from 'mocha'
+import path from 'path'
+import { parseDirectories, searchForJsonFiles, validateDirectories } from '../index'
+import { Parser } from '../interop'
+
+const fixturesFilepath = path.resolve('src/__tests__/fixtures')
+
+const exampleModel = {
+  'dtmi:com:example:base;1': {
+    languageMajorVersion: 3,
+    Id: 'dtmi:com:example:base;1',
+    ChildOf: 'dtmi:com:example;1',
+    DefinedIn: 'dtmi:com:example;1',
+    EntityKind: 'Interface',
+    ClassId: 'dtmi:dtdl:class:Interface;3',
+    extendedBy: ['dtmi:com:example;1'],
+  },
+  'dtmi:com:example;1': {
+    languageMajorVersion: 3,
+    Id: 'dtmi:com:example;1',
+    EntityKind: 'Interface',
+    ClassId: 'dtmi:dtdl:class:Interface;3',
+    extends: ['dtmi:com:example:base;1'],
+  },
+}
+
+const mockParser: Parser = {
+  parse: () => JSON.stringify(exampleModel),
+  parserVersion: () => '1.0.0',
+}
+
+const mockParserWithParsingException: Parser = {
+  parse: () => {
+    throw new Error(
+      JSON.stringify({
+        ExceptionKind: 'Parsing',
+        Errors: [{ Cause: '', Action: '', ValidationID: '' }],
+      })
+    )
+  },
+  parserVersion: () => '1.0.0',
+}
+
+const mockParserWithResolutionException: Parser = {
+  parse: () => {
+    throw new Error(
+      JSON.stringify({
+        ExceptionKind: 'Resolution',
+      })
+    )
+  },
+  parserVersion: () => '1.0.0',
+}
+
+describe('parse', () => {
+  describe('search for files', () => {
+    it('should return nested json filepaths', async () => {
+      const filepaths = searchForJsonFiles(fixturesFilepath)
+      expect(filepaths.map((fp) => path.basename(fp))).to.deep.equal(['empty.json', 'nested.json'])
+    })
+  })
+
+  describe('valid parse', () => {
+    it('should return model', async () => {
+      const model = parseDirectories(fixturesFilepath, mockParser)
+      expect(model).to.deep.equal(exampleModel)
+    })
+  })
+
+  describe('invalid directory path', () => {
+    it('should return null', async () => {
+      const model = parseDirectories('invalid', mockParser)
+      expect(model).to.equal(null)
+    })
+  })
+
+  describe('parsing exception thrown by interop parser', () => {
+    it('should return null', async () => {
+      const model = parseDirectories(fixturesFilepath, mockParserWithParsingException)
+      expect(model).to.equal(null)
+    })
+  })
+})
+
+describe('parse', () => {
+  describe('valid validate', () => {
+    it('should returned validated true', async () => {
+      const isValid = validateDirectories(fixturesFilepath, mockParser, false)
+      expect(isValid).to.equal(true)
+    })
+  })
+
+  describe('invalid directory path', () => {
+    it('should return null', async () => {
+      const isValid = validateDirectories('invalid', mockParser, false)
+      expect(isValid).to.equal(false)
+    })
+  })
+
+  describe('parsing exception thrown by interop validate', () => {
+    it('should return false', async () => {
+      const isValid = validateDirectories(fixturesFilepath, mockParserWithParsingException, false)
+      expect(isValid).to.equal(false)
+    })
+  })
+
+  describe('resolution exception thrown by interop validate', () => {
+    it('should return false if including resolution check', async () => {
+      const isValid = validateDirectories(fixturesFilepath, mockParserWithResolutionException, true)
+      expect(isValid).to.equal(false)
+    })
+
+    it('should return true if NOT including resolution check', async () => {
+      const isValid = validateDirectories(fixturesFilepath, mockParserWithResolutionException, false)
+      expect(isValid).to.equal(true)
+    })
+  })
+})

package/src/error.ts

@@ -0,0 +1,25 @@
+import { ModelingException, ParsingException, ResolutionException } from '../interop/DtdlErr.js'
+
+const { error } = console
+
+const isParsingEx = (exception: ModelingException): exception is ParsingException => {
+  return exception.ExceptionKind === 'Parsing'
+}
+
+const isResolutionEx = (exception: ModelingException): exception is ResolutionException => {
+  return exception.ExceptionKind === 'Resolution'
+}
+
+export const isResolutionException = (err: unknown) => {
+  if (!(err instanceof Error)) return false
+  return isResolutionEx(JSON.parse(err.message))
+}
+
+export const errorHandler = (err: unknown) => {
+  if (!(err instanceof Error)) return error(`Unexpected error: ${err}`)
+
+  const exception = JSON.parse(err.message) as ModelingException
+
+  if (!(isParsingEx(exception) || isResolutionEx(exception))) error('Unknown exception type')
+  error(exception)
+}