@kravc/schema 2.7.6 → 2.8.0-alpha.0

package/src/ld/getLinkedDataAttributeType.ts

@@ -0,0 +1,46 @@
+import { get } from 'lodash';
+
+export type PropertySchema = {
+  '@type'?: string;
+  $ref?: string;
+  type?: string;
+  format?: string;
+};
+
+/** Returns linked data attribute type for a property schema, unless @type is defined */
+const getLinkedDataAttributeType = (propertySchema: PropertySchema): string | undefined => {
+  const isOverriden = !!get(propertySchema, '@type');
+
+  if (isOverriden) {
+    return get(propertySchema, '@type');
+  }
+
+  // TODO: Add support for all types and formats, extend schema library with
+  //       support for additional formats, e.g. URL, Duration etc.
+  const { type, format } = propertySchema;
+
+  const isDate = format === 'date';
+  const isNumber = type === 'number';
+  const isInteger = type === 'integer';
+  const isDateTime = format === 'date-time';
+
+  if (isInteger) {
+    return 'schema:Integer';
+  }
+
+  if (isNumber) {
+    return 'schema:Number';
+  }
+
+  if (isDate) {
+    return 'schema:Date';
+  }
+
+  if (isDateTime) {
+    return 'schema:DateTime';
+  }
+
+  return;
+};
+
+export default getLinkedDataAttributeType;

package/src/ld/getLinkedDataContext.ts

@@ -0,0 +1,80 @@
+import getLinkedDataAttributeType, { type PropertySchema } from './getLinkedDataAttributeType';
+
+export type { PropertySchema };
+
+const SCHEMA_ORG_URI = 'https://schema.org/';
+
+const PROTECTED_PROPERTIES = [
+  'id',
+  'type',
+  'schema'
+];
+
+type ContextProperty = {
+  '@id': string;
+  '@type'?: string;
+};
+
+type ContextHeader = {
+  '@vocab': string;
+  '@version': number;
+  '@protected': boolean;
+  schema?: string;
+};
+
+export type LinkedDataContext = ContextHeader & {
+  [key: string]: ContextProperty | string | number | boolean | undefined;
+};
+
+/** Returns linked data context for a properties object */
+const getLinkedDataContext = (properties: Record<string, PropertySchema>, vocabUri: string): LinkedDataContext => {
+  const context = {} as Record<string, ContextProperty>;
+
+  // TODO: Add support for embedded object, array and enum.
+  for (const key in properties) {
+    const propertySchema = properties[key];
+
+    const isProtected =
+      PROTECTED_PROPERTIES.includes(key) ||
+      key.startsWith('@');
+
+    if (isProtected) {
+      continue;
+    }
+
+    context[key] = { '@id': key };
+
+    const { $ref } = propertySchema;
+
+    if ($ref) {
+      continue;
+    }
+
+    const linkedDataType = getLinkedDataAttributeType(propertySchema);
+
+    if (linkedDataType) {
+      context[key]['@type'] = linkedDataType;
+    }
+  }
+
+  const vocab = vocabUri.endsWith('/') || vocabUri.endsWith('#') ? vocabUri : `${vocabUri}#`;
+
+  const contextHeader = {
+    '@vocab': vocab,
+    '@version': 1.1,
+    '@protected': true
+  } as ContextHeader;
+
+  const isSchemaOrgDomain = vocab === SCHEMA_ORG_URI;
+
+  if (!isSchemaOrgDomain) {
+    contextHeader.schema = SCHEMA_ORG_URI;
+  }
+
+  return {
+    ...contextHeader,
+    ...context
+  };
+};
+
+export default getLinkedDataContext;

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "target": "esnext",
+    "module": "nodenext",
+    "isolatedModules": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src",
+    "types"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ]
+}

package/types/credentials-context.d.ts

@@ -0,0 +1,14 @@
+declare module 'credentials-context' {
+  /**
+   * Map of credentials context URLs to their JSON-LD context documents
+   */
+  export const contexts: Map<string, Record<string, unknown>>;
+
+  /**
+   * Constants for credentials context
+   */
+  export const constants: {
+    CREDENTIALS_CONTEXT_V1_URL: string;
+    [key: string]: string;
+  };
+}

package/types/security-context.d.ts

@@ -0,0 +1,6 @@
+declare module 'security-context' {
+  /**
+   * Map of security context URLs to their JSON-LD context documents
+   */
+  export const contexts: Map<string, Record<string, unknown>>;
+}

package/examples/Status.yaml

@@ -1,3 +0,0 @@
-enum:
-  - 'Pending'
-  - 'Active'

package/examples/createAccountCredential.js

@@ -1,27 +0,0 @@
-'use strict'
-
-const { Schema, CredentialFactory } = require('../src')
-
-const accountSchema = new Schema({
-  id:          {},
-  username:    { required: true },
-  createdAt:   { format: 'date-time', required: true },
-  dateOfBirth: { format: 'date' }
-}, 'Account')
-
-const factory = new CredentialFactory('https://example.com/schema/AccountV1', accountSchema)
-
-const createAccountCredential = (holder, username) => {
-  const id = `https://example.com/account/${username}`
-
-  const createdAt = new Date().toISOString()
-  const subject = {
-    id: holder,
-    username,
-    createdAt
-  }
-
-  return factory.createCredential(id, holder, subject)
-}
-
-module.exports = createAccountCredential

package/examples/createMineSweeperScoreCredential.js

@@ -1,63 +0,0 @@
-'use strict'
-
-const { Schema, CredentialFactory } = require('../src')
-
-const GAME_NAME    = 'MineSweeper'
-const GAME_VERSION = '1.0'
-
-const SCHEMA_ORG_URI = 'https://schema.org/'
-
-const playerSchema = new Schema({
-  id:                {},
-  hasVideoGameScore: { $ref: 'VideoGameScore', required: true }
-}, 'Player')
-
-const videoGameSchema = new Schema({
-  id:      {},
-  name:    { type: 'string', required: true },
-  version: { type: 'string', required: true }
-}, 'VideoGame', SCHEMA_ORG_URI)
-
-const videoGameScoreSchema = new Schema({
-  game:          { $ref: 'VideoGame', required: true },
-  wins:          { type: 'integer', required: true },
-  losses:        { type: 'integer', required: true },
-  winRate:       { type: 'number', required: true },
-  bestScore:     { type: 'integer', required: true },
-  // TODO: Add duration as format:
-  endurance:     { type: 'string', required: true, '@type': 'schema:Duration' },
-  dateCreated:   { type: 'string', 'format': 'date-time', required: true },
-  bestRoundTime: { type: 'integer', required: true }
-  // difficultyLevel:
-  //   enum:
-  //     - EASY
-  //     - MEDIUM
-  //     - HARD
-  //   required: true
-}, 'VideoGameScore')
-
-const CREDENTIAL_URI = `https://example.com/schema/${GAME_NAME}ScoreV1`
-const SCHEMAS = [ playerSchema, videoGameSchema, videoGameScoreSchema ]
-const factory = new CredentialFactory(CREDENTIAL_URI, SCHEMAS)
-
-const createMineSweeperScoreCredential = (gameId, playerId, playerScore) => {
-  const credentialId = 'https://example.com/credentials/CREDENTIAL_ID'
-
-  const game = {
-    id:      gameId,
-    name:    GAME_NAME,
-    version: GAME_VERSION
-  }
-
-  const player = {
-    id: playerId,
-    hasVideoGameScore: {
-      ...playerScore,
-      game
-    }
-  }
-
-  return factory.createCredential(credentialId, playerId, player)
-}
-
-module.exports = createMineSweeperScoreCredential

package/examples/index.js

@@ -1,9 +0,0 @@
-'use strict'
-
-const createAccountCredential = require('./createAccountCredential')
-const createMineSweeperScoreCredential = require('./createMineSweeperScoreCredential')
-
-module.exports = {
-  createAccountCredential,
-  createMineSweeperScoreCredential
-}

package/src/CredentialFactory.js

@@ -1,67 +0,0 @@
-'use strict'
-
-const Schema        = require('./Schema')
-const Validator     = require('./Validator')
-const validateId    = require('./helpers/validateId')
-const { constants } = require('credentials-context')
-
-const { CREDENTIALS_CONTEXT_V1_URL } = constants
-
-class CredentialFactory {
-  // TODO: Add exception when added two schemas with the same name.
-  constructor(uri, schemas) {
-    validateId('uri', uri)
-
-    this._types = [].concat(schemas).map(schema => {
-      if (schema.url) {
-        return schema
-      }
-
-      return new Schema(schema, schema.id, uri)
-    })
-
-    this._uri       = uri
-    this._context   = {}
-    this._validator = new Validator(this._types)
-
-    for (const { id, linkedDataType } of this._types) {
-      this._context[id] = linkedDataType
-    }
-  }
-
-  get credentialType() {
-    const [ credentialType ] = this._uri.split('/').reverse()
-
-    return credentialType
-  }
-
-  get context() {
-    return {
-      [this.credentialType]: { '@id': this._uri },
-      ...this._context
-    }
-  }
-
-  createCredential(id, holder, subject = {}) {
-    validateId('id', id)
-    validateId('holder', holder)
-
-    const type = [ 'VerifiableCredential', this.credentialType ]
-
-    const [ rootType ]      = this._types
-    const credentialSubject = this._validator.validate(subject, rootType.id)
-
-    return {
-      '@context': [
-        CREDENTIALS_CONTEXT_V1_URL,
-        this.context
-      ],
-      id,
-      type,
-      holder,
-      credentialSubject
-    }
-  }
-}
-
-module.exports = CredentialFactory

package/src/CredentialFactory.spec.js

@@ -1,131 +0,0 @@
-'use strict'
-
-const Schema            = require('./Schema')
-const { expect }        = require('chai')
-const { canonize }      = require('jsonld')
-const documentLoader    = require('./ld/documentLoader')
-const CredentialFactory = require('./CredentialFactory')
-const {
-  createAccountCredential,
-  createMineSweeperScoreCredential
-} = require('examples')
-
-describe('CredentialFactory', () => {
-  describe('CredentialFactory.constructor(uri, schemas)', () => {
-    it('throws error if "uri" parameter is missing', () => {
-      expect(
-        () => new CredentialFactory()
-      ).to.throw()
-    })
-
-    it('throws error if "uri" parameter is not a URL', () => {
-      expect(
-        () => new CredentialFactory('BAD_URL')
-      ).to.throw()
-    })
-  })
-
-  describe('.createCredential(id, holder, subject = {}, subjectTypeId = null)', () => {
-    let factory
-
-    before(() => {
-      const videoGameSchema = new Schema({
-        id:      {},
-        name:    { type: 'string', required: true },
-        version: { type: 'string', required: true }
-      }, 'VideoGame', 'https://schema.org/')
-
-      factory = new CredentialFactory('https://example.com/StarCraft', videoGameSchema)
-    })
-
-    it('returns single schema based credential', async () => {
-      const credential = await createAccountCredential('did:PLAYER_ID', 'CAHTEP')
-
-      expect(credential).to.exist
-      await canonize(credential, { documentLoader })
-
-      const { credentialSubject: { createdAt } } = credential
-      expect(credential).to.eql({
-        '@context': [
-          'https://www.w3.org/2018/credentials/v1',
-          {
-            AccountV1: { '@id': 'https://example.com/schema/AccountV1' },
-            Account: {
-              '@id': 'https://example.com/schema/AccountV1#Account',
-              '@context': {
-                '@vocab': 'https://example.com/schema/AccountV1#',
-                '@version': 1.1,
-                '@protected': true,
-                schema: 'https://schema.org/',
-                username: { '@id': 'username' },
-                createdAt: { '@id': 'createdAt', '@type': 'schema:DateTime' },
-                dateOfBirth: { '@id': 'dateOfBirth', '@type': 'schema:Date' }
-              }
-            }
-          }
-        ],
-        id: 'https://example.com/account/CAHTEP',
-        type: [ 'VerifiableCredential', 'AccountV1' ],
-        holder: 'did:PLAYER_ID',
-        credentialSubject: {
-          id: 'did:PLAYER_ID',
-          username: 'CAHTEP',
-          createdAt,
-          type: 'Account'
-        }
-      })
-    })
-
-    it('returns multiple schemas based credential', async () => {
-      const playerScore = {
-        wins:          5,
-        losses:        5,
-        winRate:       50,
-        UNDEFINED:     'VALUE',
-        bestScore:     23450,
-        endurance:     'P5M22S',
-        dateCreated:   '2020-10-10T00:00:00Z',
-        bestRoundTime: 10000
-      }
-
-      const credential = await createMineSweeperScoreCredential(
-        'did:GAME_ID',
-        'did:PLAYER_ID',
-        playerScore
-      )
-
-      expect(credential).to.exist
-      await canonize(credential, { documentLoader })
-
-      const { credentialSubject } = credential
-      expect(credentialSubject.type).to.equal('Player')
-      expect(credentialSubject.hasVideoGameScore.type).to.equal('VideoGameScore')
-      expect(credentialSubject.hasVideoGameScore.game.type).to.equal('VideoGame')
-      expect(credentialSubject.hasVideoGameScore.UNDEFINED).to.not.exist
-
-      const customContext = credential['@context'][1]
-      expect(customContext.VideoGame).to.eql({
-        '@id': 'https://schema.org/VideoGame',
-        '@context': {
-          '@protected': true,
-          '@version': 1.1,
-          '@vocab': 'https://schema.org/',
-          name: { '@id': 'name' },
-          version: { '@id': 'version' }
-        }
-      })
-    })
-
-    it('throws error if "id" parameter is missing', () => {
-      expect(
-        () => factory.createCredential()
-      ).to.throw('Parameter "id" is required')
-    })
-
-    it('throws error if "holder" parameter is missing', () => {
-      expect(
-        () => factory.createCredential('did:CREDENTIAL_ID')
-      ).to.throw('Parameter "holder" is required')
-    })
-  })
-})

package/src/Schema.js

@@ -1,104 +0,0 @@
-'use strict'
-
-const { pick, cloneDeep }  = require('lodash')
-const validateId           = require('./helpers/validateId')
-const normalizeRequired    = require('./helpers/normalizeRequired')
-const normalizeProperties  = require('./helpers/normalizeProperties')
-const getLinkedDataContext = require('./ld/getLinkedDataContext')
-const removeRequiredAndDefault = require('./helpers/removeRequiredAndDefault')
-
-const UNDEFINED_SCHEMA_ID = 'UNDEFINED_SCHEMA_ID'
-
-class Schema {
-  constructor(source = {}, id = UNDEFINED_SCHEMA_ID, url) {
-    this._id     = id
-    this._url    = url
-    this._source = source instanceof Schema ? source.source : source
-
-    if (url) {
-      validateId('url', url)
-
-      this._source.type = { required: true, type: 'string', default: id }
-
-      if (this._source.id) {
-        this._source.id = { required: true, type: 'string', format: 'url' }
-      }
-
-      const uri =
-        (url.endsWith('/') || url.endsWith('#')) ? `${url}${id}` : `${url}#${id}`
-
-      this._linkedDataType = {
-        '@id':      uri,
-        '@context': getLinkedDataContext(this._source, url)
-      }
-    }
-
-    normalizeProperties(this._source)
-  }
-
-  get id() {
-    return this._id
-  }
-
-  get url() {
-    return this._url
-  }
-
-  get source() {
-    return cloneDeep(this._source)
-  }
-
-  get jsonSchema() {
-    if (this._source.enum) {
-      return {
-        id: this._id,
-        ...this.source
-      }
-    }
-
-    const jsonSchema = {
-      id:         this._id,
-      type:       'object',
-      properties: this.source
-    }
-
-    normalizeRequired(jsonSchema)
-
-    return jsonSchema
-  }
-
-  get linkedDataType() {
-    return this._linkedDataType
-  }
-
-  clone(id) {
-    return new Schema(this.source, id)
-  }
-
-  pure(id) {
-    const { properties: source } = removeRequiredAndDefault({ properties: this.source })
-    return new Schema(source, id)
-  }
-
-  only(propertyNames, id) {
-    const source = pick(this.source, propertyNames)
-    return new Schema(source, id)
-  }
-
-  extend(properties, id) {
-    return new Schema({ ...this.source, ...properties }, id)
-  }
-
-  wrap(propertyName, options = { required: true }, id) {
-    const source = {
-      [propertyName]: {
-        properties: this.source,
-        ...options
-      }
-    }
-
-    return new Schema(source, id)
-  }
-}
-
-module.exports = Schema