0.53.0

CHANGELOG.md

@@ -1,3 +1,51 @@
+# [0.52.0](https://gitlab.com/openstapps/core/compare/v0.51.0...v0.52.0) (2021-09-28)
+
+
+### Features
+
+* add about config ([aa294c4](https://gitlab.com/openstapps/core/commit/aa294c4e29e9191bef6d79487b0b321fbc34f6fb))
+
+
+
+# [0.51.0](https://gitlab.com/openstapps/core/compare/v0.50.0...v0.51.0) (2021-09-10)
+
+
+### Bug Fixes
+
+* add physicalobject to book categories ([ded8e7d](https://gitlab.com/openstapps/core/commit/ded8e7dfd51094c02a86e1383a4e94c069c10e64))
+
+
+
+# [0.50.0](https://gitlab.com/openstapps/core/compare/v0.49.5...v0.50.0) (2021-09-01)
+
+
+
+## [0.49.5](https://gitlab.com/openstapps/core/compare/v0.49.3...v0.49.5) (2021-08-27)
+
+
+### Bug Fixes
+
+* test resources from hds2 ([dfe35d7](https://gitlab.com/openstapps/core/commit/dfe35d71a38c35064726365f99714abff3b30ba6))
+
+
+
+## [0.49.3](https://gitlab.com/openstapps/core/compare/v0.49.2...v0.49.3) (2021-08-18)
+
+
+
+## [0.49.2](https://gitlab.com/openstapps/core/compare/v0.49.1...v0.49.2) (2021-08-17)
+
+
+
+## [0.49.1](https://gitlab.com/openstapps/core/compare/v0.49.0...v0.49.1) (2021-08-13)
+
+
+### Bug Fixes
+
+* documentation generation ([8a28d6f](https://gitlab.com/openstapps/core/commit/8a28d6fa8657d778d6ae0d38cda7da3531d6478c))
+
+
+
 # [0.49.0](https://gitlab.com/openstapps/core/compare/v0.48.0...v0.49.0) (2021-08-12)
 
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openstapps/core",
-  "version": "0.49.1",
+  "version": "0.53.0",
   "description": "StAppsCore - Generalized model of data",
   "keywords": [
     "Model",
@@ -45,7 +45,7 @@
     "Wieland Schöbl"
   ],
   "dependencies": {
-    "@openstapps/core-tools": "0.23.2",
+    "@openstapps/core-tools": "0.25.0",
     "@types/geojson": "1.0.6",
     "@types/json-patch": "0.0.30",
     "@types/json-schema": "7.0.9",
@@ -62,11 +62,14 @@
     "@openstapps/es-mapping-generator": "0.0.3",
     "@openstapps/logger": "0.7.0",
     "@testdeck/mocha": "0.1.2",
+    "@types/lodash": "4.14.172",
     "@types/chai": "4.2.21",
     "@types/rimraf": "3.0.1",
+    "@types/mocha": "8.2.3",
     "chai": "4.3.4",
     "conditional-type-checks": "1.0.5",
     "conventional-changelog-cli": "2.1.1",
+    "lodash": "4.17.21",
     "mocha": "8.4.0",
     "nyc": "15.1.0",
     "rimraf": "3.0.2",
@@ -74,7 +77,7 @@
     "surge": "0.23.0",
     "ts-node": "9.1.1",
     "tslint": "6.1.3",
-    "typedoc": "0.21.5",
+    "typedoc": "0.21.6",
     "typescript": "4.3.5"
   },
   "nyc": {

src/config/app.ts

@@ -15,6 +15,7 @@
 // tslint:disable-next-line:no-implicit-dependencies
 import {Polygon} from 'geojson';
 import {SCTranslations} from '../general/i18n';
+import {SCMap} from '../general/map';
 import {SCLanguageSetting, SCSetting, SCUserGroupSetting} from '../things/setting';
 
 /**
@@ -80,6 +81,13 @@ export interface SCAppConfigurationMenuCategory {
  * An app configuration
  */
 export interface SCAppConfiguration {
+  /**
+   * The about page
+   *
+   * Mapping route -> page config
+   */
+  aboutPages: SCMap<SCAboutPage>;
+
   /**
    * Polygon that encapsulates the main campus
    */
@@ -174,3 +182,147 @@ export interface SCAppConfigurationMenuCategoryTranslationName {
    */
   name: string;
 }
+
+export enum SCAboutPageContentType {
+  SECTION = 'section',
+  ROUTER_LINK = 'router link',
+  TABLE = 'table',
+  MARKDOWN = 'markdown',
+}
+
+export interface SCAboutPageTranslationTitle {
+  /**
+   * Translation of the title
+   */
+  title: string;
+}
+
+export interface SCAboutPageTranslationValue {
+  /**
+   * Translation of the value
+   */
+  value: string;
+}
+
+/**
+ * A (mostly) self-contained section, akin to markdown `# Title`
+ */
+export interface SCAboutPageSection {
+  /**
+   * If the section should be contained in a card
+   */
+  card?: true;
+
+  /**
+   * The content of the section
+   */
+  content: SCAboutPageContent;
+
+  /**
+   * The title of the section
+   */
+  title: string;
+
+  /**
+   * Translations
+   */
+  translations: SCTranslations<SCAboutPageTranslationTitle>;
+
+  /**
+   * Type
+   */
+  type: SCAboutPageContentType.SECTION;
+}
+
+/**
+ * A router link that can lead to a new page
+ *
+ * For external links, prefer markdown `[destination](link)`
+ */
+export interface SCAboutPageRouterLink {
+  /**
+   * Icon of the destination
+   */
+  icon?: string;
+
+  /**
+   * Router link
+   */
+  link: string;
+
+  /**
+   * Title of the destination
+   */
+  title: string;
+
+  /**
+   * Translations
+   */
+  translations: SCTranslations<SCAboutPageTranslationTitle>;
+
+  /**
+   * Type
+   */
+  type: SCAboutPageContentType.ROUTER_LINK;
+}
+
+/**
+ * A simple table element
+ */
+export interface SCAboutPageTable {
+  /**
+   * Rows of the table
+   */
+  rows: SCAboutPageContent[][];
+
+  /**
+   * Type
+   */
+  type: SCAboutPageContentType.TABLE;
+}
+
+/**
+ * A markdown element
+ */
+export interface SCAboutPageMarkdown {
+  /**
+   * Translations
+   */
+  translations: SCTranslations<SCAboutPageTranslationValue>;
+
+  /**
+   * Type
+   */
+  type: SCAboutPageContentType.MARKDOWN;
+
+  /**
+   * Value (Markdown)
+   */
+  value: string;
+}
+
+export type SCAboutPageContent =
+  | SCAboutPageMarkdown
+  | SCAboutPageTable
+  | SCAboutPageSection
+  | SCAboutPageRouterLink;
+
+/**
+ * Root of the about page
+ */
+export interface SCAboutPage {
+  /**
+   * Content of the page
+   */
+  content: SCAboutPageContent[];
+
+  /**
+   * Header (title) of the page
+   */
+  title: string;
+
+  /**
+   * Translations
+   */
+  translations: SCTranslations<SCAboutPageTranslationTitle>;
+}

src/protocol/errors/internal-server-error.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {BAD_GATEWAY} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
@@ -34,7 +34,7 @@ export class SCInternalServerErrorResponse extends SCError {
    * and the internal server error should be displayed to the client
    */
   constructor(err?: Error, stack = false) {
-    super('InternalServerError', 'Internal server error', BAD_GATEWAY, stack);
+    super('InternalServerError', 'Internal server error', StatusCodes.BAD_GATEWAY, stack);
 
     if (stack) {
       this.additionalData = err;

src/protocol/errors/method-not-allowed.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {METHOD_NOT_ALLOWED} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
@@ -27,6 +27,6 @@ export class SCMethodNotAllowedErrorResponse extends SCError {
    * @param stack Set to true if a stack trace should be created
    */
   constructor(stack?: boolean) {
-    super('MethodNotAllowedError', 'HTTP method is not allowed on this route', METHOD_NOT_ALLOWED, stack);
+    super('MethodNotAllowedError', 'HTTP method is not allowed on this route', StatusCodes.METHOD_NOT_ALLOWED, stack);
   }
 }

src/protocol/errors/not-found.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {NOT_FOUND} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
@@ -27,6 +27,6 @@ export class SCNotFoundErrorResponse extends SCError {
    * @param stack Set to true if a stack trace should be created
    */
   constructor(stack?: boolean) {
-    super('NotFoundError', 'Resource not found', NOT_FOUND, stack);
+    super('NotFoundError', 'Resource not found', StatusCodes.NOT_FOUND, stack);
   }
 }

src/protocol/errors/parameters-not-acceptable.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {NOT_ACCEPTABLE} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
@@ -29,6 +29,6 @@ export class SCParametersNotAcceptable extends SCError {
    * @param stack Set to true if a stack trace should be created
    */
   constructor(message: string, stack?: boolean) {
-    super('ParametersNotAcceptable', message, NOT_ACCEPTABLE, stack);
+    super('ParametersNotAcceptable', message, StatusCodes.NOT_ACCEPTABLE, stack);
   }
 }

src/protocol/errors/plugin-already-registered.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {CONFLICT} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 import {SCPluginMetaData} from '../routes/plugin-register';
 
@@ -38,7 +38,7 @@ export class SCPluginAlreadyRegisteredErrorResponse extends SCError {
    * @param stack Set to true if a stack trace should be created
    */
   constructor(message: string, plugin: SCPluginMetaData, stack = false) {
-    super('SCPluginAlreadyRegisteredError', message, CONFLICT, stack);
+    super('SCPluginAlreadyRegisteredError', message, StatusCodes.CONFLICT, stack);
     if (stack) {
       this.additionalData = plugin;
     }

src/protocol/errors/plugin-registering-failed.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {INTERNAL_SERVER_ERROR} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
@@ -28,6 +28,6 @@ export class SCPluginRegisteringFailedErrorResponse extends SCError {
    * @param stack Set to true if a stack trace should be created
    */
   constructor(message: string, stack?: boolean) {
-    super('PluginRegisteringFailedError', message, INTERNAL_SERVER_ERROR, stack);
+    super('PluginRegisteringFailedError', message, StatusCodes.INTERNAL_SERVER_ERROR, stack);
   }
 }

src/protocol/errors/request-body-too-large.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {REQUEST_TOO_LONG} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
@@ -27,6 +27,6 @@ export class SCRequestBodyTooLargeErrorResponse extends SCError {
    * @param stack Set to true if a stack trace should be created
    */
   constructor(stack?: boolean) {
-    super('RequestBodyTooLargeError', 'The request body is too large.', REQUEST_TOO_LONG, stack);
+    super('RequestBodyTooLargeError', 'The request body is too large.', StatusCodes.REQUEST_TOO_LONG, stack);
   }
 }

src/protocol/errors/syntax-error.ts

@@ -12,12 +12,12 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {BAD_REQUEST} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
  * An error that is returned whenever there is a syntax error
- * 
+ *
  * @validatable
  */
 export class SCSyntaxErrorResponse extends SCError {
@@ -28,6 +28,6 @@ export class SCSyntaxErrorResponse extends SCError {
    * @param stack Set to true if a stack trace should be created
    */
   constructor(message: string, stack?: boolean) {
-    super('SyntaxError', message, BAD_REQUEST, stack);
+    super('SyntaxError', message, StatusCodes.BAD_REQUEST, stack);
   }
 }

src/protocol/errors/too-many-requests.ts

@@ -12,12 +12,12 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {TOO_MANY_REQUESTS} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
  * An error that is returned, when to many request are submitted at once
- * 
+ *
  * @validatable
  */
 export class SCTooManyRequestsErrorResponse extends SCError {
@@ -30,7 +30,7 @@ export class SCTooManyRequestsErrorResponse extends SCError {
     super(
       'TooManyRequestsError',
       'Too many requests. You can not submit more than 5 queries an once',
-      TOO_MANY_REQUESTS,
+      StatusCodes.TOO_MANY_REQUESTS,
       stack,
     );
   }

src/protocol/errors/unsupported-media-type.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {UNSUPPORTED_MEDIA_TYPE} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
@@ -27,6 +27,6 @@ export class SCUnsupportedMediaTypeErrorResponse extends SCError {
    * @param stack Set to true if a stack trace should be created
    */
   constructor(stack?: boolean) {
-    super('UnsupportedMediaTypeError', 'Unsupported media type', UNSUPPORTED_MEDIA_TYPE, stack);
+    super('UnsupportedMediaTypeError', 'Unsupported media type', StatusCodes.UNSUPPORTED_MEDIA_TYPE, stack);
   }
 }

src/protocol/errors/validation.ts

@@ -12,8 +12,8 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {ValidationError} from '@openstapps/core-tools/lib/common';
-import {BAD_REQUEST} from 'http-status-codes';
+import {ValidationError} from '@openstapps/core-tools/lib/types/validator';
+import {StatusCodes} from 'http-status-codes';
 import {SCError} from '../error';
 
 /**
@@ -34,7 +34,7 @@ export class SCValidationErrorResponse extends SCError {
    * @param stack Set to true if a stack trace should be created
    */
   constructor(errors: ValidationError[], stack?: boolean) {
-    super('ValidationError', 'Validation of request failed', BAD_REQUEST, stack);
+    super('ValidationError', 'Validation of request failed', StatusCodes.BAD_REQUEST, stack);
     this.additionalData = errors;
   }
 }

src/protocol/routes/book-availability.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {OK} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCUuid} from '../../general/uuid';
 import {SCAcademicPriceGroup, SCThingThatCanBeOfferedOffer} from '../../things/abstract/thing-that-can-be-offered';
 import {SCInternalServerErrorResponse} from '../errors/internal-server-error';
@@ -88,7 +88,7 @@ export class SCBookAvailabilityRoute extends SCAbstractRoute {
     this.method = SCRouteHttpVerbs.POST;
     this.requestBodyName = 'SCBookAvailabilityRequest';
     this.responseBodyName = 'SCBookAvailabilityResponse';
-    this.statusCodeSuccess = OK;
+    this.statusCodeSuccess = StatusCodes.OK;
     this.urlFragment = '/bookAvailability';
   }
 }

src/protocol/routes/bulk-add.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {CREATED} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCThings} from '../../meta';
 import {SCInternalServerErrorResponse} from '../errors/internal-server-error';
 import {SCMethodNotAllowedErrorResponse} from '../errors/method-not-allowed';
@@ -59,7 +59,7 @@ export class SCBulkAddRoute extends SCAbstractRoute {
     };
     this.requestBodyName = 'SCBulkAddRequest';
     this.responseBodyName = 'SCBulkAddResponse';
-    this.statusCodeSuccess = CREATED;
+    this.statusCodeSuccess = StatusCodes.CREATED;
     this.urlFragment = '/bulk/:UID';
   }
 }

src/protocol/routes/bulk-done.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {NO_CONTENT} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCInternalServerErrorResponse} from '../errors/internal-server-error';
 import {SCMethodNotAllowedErrorResponse} from '../errors/method-not-allowed';
 import {SCNotFoundErrorResponse} from '../errors/not-found';
@@ -59,7 +59,7 @@ export class SCBulkDoneRoute extends SCAbstractRoute {
     };
     this.requestBodyName = 'SCBulkDoneRequest';
     this.responseBodyName = 'SCBulkDoneResponse';
-    this.statusCodeSuccess = NO_CONTENT;
+    this.statusCodeSuccess = StatusCodes.NO_CONTENT;
     this.urlFragment = '/bulk/:UID/done';
   }
 }

src/protocol/routes/bulk-request.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {OK} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCISO8601Date} from '../../general/time';
 import {SCUuid} from '../../general/uuid';
 import {SCThingType} from '../../things/abstract/thing';
@@ -98,7 +98,7 @@ export class SCBulkRoute extends SCAbstractRoute {
     this.method = SCRouteHttpVerbs.POST;
     this.requestBodyName = 'SCBulkRequest';
     this.responseBodyName = 'SCBulkResponse';
-    this.statusCodeSuccess = OK;
+    this.statusCodeSuccess = StatusCodes.OK;
     this.urlFragment = '/bulk';
   }
 }

src/protocol/routes/feedback.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {NO_CONTENT} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCMessage} from '../../things/message';
 import {SCInternalServerErrorResponse} from '../errors/internal-server-error';
 import {SCMethodNotAllowedErrorResponse} from '../errors/method-not-allowed';
@@ -59,7 +59,7 @@ export class SCFeedbackRoute extends SCAbstractRoute {
     this.method = SCRouteHttpVerbs.POST;
     this.requestBodyName = 'SCFeedbackRequest';
     this.responseBodyName = 'SCFeedbackResponse';
-    this.statusCodeSuccess = NO_CONTENT;
+    this.statusCodeSuccess = StatusCodes.OK;
     this.urlFragment = '/feedback';
   }
 }

src/protocol/routes/index.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {OK} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCAppConfiguration} from '../../config/app';
 import {SCBackendConfiguration} from '../../config/backend';
 import {SCInternalServerErrorResponse} from '../errors/internal-server-error';
@@ -65,7 +65,7 @@ export class SCIndexRoute extends SCAbstractRoute {
     this.method = SCRouteHttpVerbs.POST;
     this.requestBodyName = 'SCIndexRequest';
     this.responseBodyName = 'SCIndexResponse';
-    this.statusCodeSuccess = OK;
+    this.statusCodeSuccess = StatusCodes.OK;
     this.urlFragment = '/';
   }
 }

src/protocol/routes/plugin-register.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {OK} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {JSONSchema7} from 'json-schema';
 import {SCInternalServerErrorResponse} from '../errors/internal-server-error';
 import {SCMethodNotAllowedErrorResponse} from '../errors/method-not-allowed';
@@ -122,7 +122,7 @@ export class SCPluginRegisterRoute extends SCAbstractRoute {
     this.method = SCRouteHttpVerbs.POST;
     this.requestBodyName = 'SCPluginRegisterRequest';
     this.responseBodyName = 'SCPluginRegisterResponse';
-    this.statusCodeSuccess = OK;
+    this.statusCodeSuccess = StatusCodes.OK;
     this.urlFragment = '/plugin/register';
   }
 }

src/protocol/routes/search-multi.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {OK} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCMap} from '../../general/map';
 import {SCInternalServerErrorResponse} from '../errors/internal-server-error';
 import {SCMethodNotAllowedErrorResponse} from '../errors/method-not-allowed';
@@ -63,7 +63,7 @@ export class SCMultiSearchRoute extends SCAbstractRoute {
     this.method = SCRouteHttpVerbs.POST;
     this.requestBodyName = 'SCMultiSearchRequest';
     this.responseBodyName = 'SCMultiSearchResponse';
-    this.statusCodeSuccess = OK;
+    this.statusCodeSuccess = StatusCodes.OK;
     this.urlFragment = '/search/multi';
   }
 }

src/protocol/routes/search.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {OK} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCInternalServerErrorResponse} from '../errors/internal-server-error';
 import {SCMethodNotAllowedErrorResponse} from '../errors/method-not-allowed';
 import {SCRequestBodyTooLargeErrorResponse} from '../errors/request-body-too-large';
@@ -56,7 +56,7 @@ export class SCSearchRoute extends SCAbstractRoute {
     this.method = SCRouteHttpVerbs.POST;
     this.requestBodyName = 'SCSearchRequest';
     this.responseBodyName = 'SCSearchResponse';
-    this.statusCodeSuccess = OK;
+    this.statusCodeSuccess = StatusCodes.OK;
     this.urlFragment = '/search';
   }
 }

src/protocol/routes/thing-update.ts

@@ -12,7 +12,7 @@
  * You should have received a copy of the GNU General Public License along with
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import {OK} from 'http-status-codes';
+import {StatusCodes} from 'http-status-codes';
 import {SCThings} from '../../meta';
 import {SCInternalServerErrorResponse} from '../errors/internal-server-error';
 import {SCMethodNotAllowedErrorResponse} from '../errors/method-not-allowed';
@@ -60,7 +60,7 @@ export class SCThingUpdateRoute extends SCAbstractRoute {
     };
     this.requestBodyName = 'SCThingUpdateRequest';
     this.responseBodyName = 'SCThingUpdateResponse';
-    this.statusCodeSuccess = OK;
+    this.statusCodeSuccess = StatusCodes.OK;
     this.urlFragment = '/:TYPE/:UID';
   }
 }

src/things/book.ts

@@ -43,6 +43,7 @@ export type SCBookCategories = 'audio'
   | 'microfilm'
   | 'musicalscore'
   | 'photo'
+  | 'physicalobject'
   | 'retro'
   | 'sensorimage'
   | 'unknown'

test/compat.spec.ts

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import {lightweightProjectFromPath} from '@openstapps/core-tools/lib/easy-ast/easy-ast';
+import {LightweightProject} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-project';
+import {expect} from 'chai';
+import {reduce} from 'lodash';
+
+process.on('unhandledRejection', (err) => {
+  throw err;
+});
+
+describe('Mapping Compatibility', () => {
+  let project: LightweightProject;
+
+  before(function () {
+    this.timeout(15000);
+    this.slow(10000);
+
+    project = lightweightProjectFromPath('src');
+  });
+
+  it('non-exported definitions should not have duplicate names across files', () => {
+    reduce(project, (result, file) => reduce(file, (result2, _, key) => {
+      expect(result2[key]).to.be.undefined;
+      return {
+        [key]: true,
+        ...result2,
+      };
+    }, result), {} as Record<string, boolean>);
+  });
+});

test/features.spec.ts

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2018 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {isLightweightClass, isLightweightEnum, isUnionType} from '@openstapps/core-tools/lib/easy-ast/ast-util';
+import {LightweightAliasDefinition} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-alias-definition';
+import {LightweightProjectWithIndex} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-project';
+import {LightweightType} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-type';
+import {LightweightClassDefinition} from '@openstapps/core-tools/src/easy-ast/types/lightweight-class-definition';
+import {LightweightDefinition} from '@openstapps/core-tools/src/easy-ast/types/lightweight-definition';
+import {LightweightProperty} from '@openstapps/core-tools/src/easy-ast/types/lightweight-property';
+import {expect} from 'chai';
+import {assign, chain, clone, flatMap, isNil, reduce, reject, some} from 'lodash';
+
+process.on('unhandledRejection', (err) => {
+  throw err;
+});
+
+describe('Features', () => {
+  let project: LightweightProjectWithIndex;
+  let thingNames: string[];
+  let things: LightweightClassDefinition[];
+  let thingsWithoutReferences: LightweightClassDefinition[];
+
+  before(function () {
+    this.timeout(15000);
+    this.slow(10000);
+
+    project = new LightweightProjectWithIndex('src');
+
+    const thingsReflection = project.definitions['SCIndexableThings'] as LightweightAliasDefinition;
+    expect(isLightweightEnum(thingsReflection)).to.be.true;
+    expect(isUnionType(thingsReflection.type!)).to.be.true;
+
+    thingsReflection.type!.specificationTypes!.push({
+      flags: 524_288,
+      referenceName: 'SCDiff',
+    });
+
+    // tslint:disable-next-line:no-unused-expression
+    expect(thingsReflection.type?.specificationTypes?.every(it => typeof it.referenceName !== 'undefined')).to.be.true;
+    thingNames = thingsReflection.type?.specificationTypes?.map(type => type.referenceName!) ?? [];
+    things = thingNames
+      .map(it => project.definitions[it])
+      .filter(isLightweightClass);
+    thingsWithoutReferences = thingNames
+      .map(it => project.definitions[`${it}WithoutReferences`])
+      .filter(isLightweightClass);
+  });
+
+  const inheritedProperties = function (classLike: LightweightClassDefinition):
+    Record<string, LightweightProperty> | undefined {
+    return reduce(
+      [...(classLike.implementedDefinitions ?? []), ...(classLike.extendedDefinitions ?? [])],
+      (obj, extension) => {
+        const object = project.definitions[extension.referenceName ?? ''];
+
+        return assign(obj, isLightweightClass(object)
+          ? inheritedProperties(object)
+          : obj);
+      },
+      clone(classLike.properties)
+    );
+  };
+
+  it('should have an origin', () => {
+    for (const thing of things) {
+      expect(inheritedProperties(thing)?.['origin']).not.to.be.undefined;
+    }
+  });
+
+  it('should not have duplicate names', () => {
+    reduce(project.files, (fileResult, file) =>
+      reduce(file, (definitionResult, definition: LightweightDefinition) => {
+        expect(definitionResult[definition.name]).to.be.undefined;
+        definitionResult[definition.name] = true; // something that's not undefined
+
+        return definitionResult;
+      }, fileResult), {} as Record<string, true>);
+  });
+
+  it('should not have properties referencing SCThing', () => {
+    const allPropertyReferenceNames: (property: LightweightProperty) => string[] = property => reject([
+      property.type.referenceName!,
+      ...flatMap(property.properties, allPropertyReferenceNames),
+    ], isNil);
+
+    const typeHasSCThingReferences: (type?: LightweightType) => boolean = type => type?.referenceName
+      ? hasSCThingReferences(project.definitions[type.referenceName])
+      : some(type?.specificationTypes, typeHasSCThingReferences);
+
+    const hasSCThingReferences: (definition?: LightweightDefinition) => boolean = definition =>
+      isLightweightClass(definition)
+        ? chain(inheritedProperties(definition))
+          .flatMap(it => flatMap(it.properties, allPropertyReferenceNames))
+          .map(it => project.definitions[it] as LightweightDefinition)
+          .some(it => it.name === 'SCThing' || hasSCThingReferences(it))
+          .value()
+        : definition ? typeHasSCThingReferences(definition.type) : false;
+
+    for (const thing of things) {
+      expect(hasSCThingReferences(thing)).to.be.false;
+    }
+  });
+
+  function extendsSCThing(definition?: LightweightDefinition): boolean {
+    return isLightweightClass(definition)
+      ? chain([
+        ...(definition as LightweightClassDefinition).extendedDefinitions ?? [],
+        ...(definition as LightweightClassDefinition).implementedDefinitions ?? [],
+      ])
+        .map(it => it.referenceName)
+        .reject(isNil)
+        .some(it => it === 'SCThing' || extendsSCThing(project.definitions[it!]))
+        .value()
+      : false;
+  }
+
+  it('should extend SCThing if it is an SCThing', () => {
+    for (const thing of things) {
+      expect(extendsSCThing(thing)).to.be.true;
+    }
+  });
+
+  it('should not extend SCThing if it is an SCThingWithoutReferences', () => {
+    for (const thingWithoutReferences of thingsWithoutReferences) {
+      expect(extendsSCThing(thingWithoutReferences)).to.be.false;
+    }
+  });
+});

test/resources/indexable/Article.3.json

@@ -22,7 +22,7 @@
       "name": "HeBIS HDS",
       "originalId": "HEB198305427",
       "type": "remote",
-      "url": "https://hds2test.hebis.de/ubffm/"
+      "url": "https://hds2.hebis.de/ubffm/"
     },
     "isPartOf": {
       "uid": "bc5e5399-a24c-5c01-9c1b-0c8b83272087",

test/resources/indexable/Article.4.json

@@ -22,7 +22,7 @@
       "name": "HeBIS HDS",
       "originalId": "HEB107025590",
       "type": "remote",
-      "url": "https://hds2test.hebis.de/ubffm/"
+      "url": "https://hds2.hebis.de/ubffm/"
     },
     "isPartOf": {
       "uid": "f84c1851-042e-542f-ba7a-158b32dfb82f",

test/resources/indexable/Book.3.json

@@ -33,7 +33,7 @@
       "name": "HeBIS HDS",
       "originalId": "HEB022992618",
       "type": "remote",
-      "url": "https://hds2test.hebis.de/ubffm/"
+      "url": "https://hds2.hebis.de/ubffm/"
     }
   },
   "schema": "SCBook"

test/resources/indexable/Book.4.json

@@ -18,7 +18,7 @@
     "firstPublished": "2001",
     "publications": [
       {
-        "uid": "603a6574-8910-588a-9e83-cd26e6988c74",
+        "uid": "6333427c-0725-5398-9a04-11604680dae3",
         "type": "publication event",
         "locations": [
           "Paris"
@@ -36,7 +36,7 @@
       "name": "HeBIS HDS",
       "originalId": "HEB102248788",
       "type": "remote",
-      "url": "https://hds2test.hebis.de/ubffm/"
+      "url": "https://hds2.hebis.de/ubffm/"
     }
   },
   "schema": "SCBook"

test/resources/indexable/Message.2.json

@@ -1,6 +1,6 @@
 {
   "errorNames": [
-    "enum"
+    "const"
   ],
   "instance": {
     "type": "invalid-value-in-schema",

test/resources/indexable/Periodical.1.json

@@ -28,7 +28,7 @@
       "name": "HeBIS HDS",
       "originalId": "HEB046847146",
       "type": "remote",
-      "url": "https://hds2test.hebis.de/ubffm/"
+      "url": "https://hds2.hebis.de/ubffm/"
     }
   },
   "schema": "SCPeriodical"

test/resources/indexable/Periodical.2.json

@@ -25,7 +25,7 @@
       "name": "HeBIS HDS",
       "originalId": "HEB048624853",
       "type": "remote",
-      "url": "https://hds2test.hebis.de/ubffm/"
+      "url": "https://hds2.hebis.de/ubffm/"
     }
   },
   "schema": "SCPeriodical"

test/schema.spec.ts

@@ -1,324 +1,17 @@
-/*
- * Copyright (C) 2018 StApps
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, version 3.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program. If not, see <https://www.gnu.org/licenses/>.
- */
-import {getTsconfigPath} from '@openstapps/core-tools/lib/common';
 import {validateFiles, writeReport} from '@openstapps/core-tools/lib/validate';
-import {Logger} from '@openstapps/logger';
-import {fail} from 'assert';
-import {expect} from 'chai';
-import {mkdirSync, PathLike} from 'fs';
 import {slow, suite, test, timeout} from '@testdeck/mocha';
+import {expect} from 'chai';
+import {mkdirSync} from 'fs';
 import {join, resolve} from 'path';
-import {Application, DeclarationReflection, ProjectReflection, TSConfigReader} from 'typedoc';
-import {ArrayType, IntrinsicType, ReferenceType, LiteralType, Type, UnionType} from 'typedoc/dist/lib/models';
-
-process.on('unhandledRejection', (err) => {
-  throw err;
-});
-
-/**
- * Get a project reflection from a path
- *
- * @param srcPath Path to get reflection from
- * @param excludeExternals Exclude external dependencies
- */
-export function getProjectReflection(srcPath: PathLike, excludeExternals = true): ProjectReflection {
-  Logger.info(`Generating project reflection for ${srcPath.toString()}.`);
-
-  const tsconfigPath = getTsconfigPath(srcPath.toString());
-  let inputFilePath = srcPath;
-  if (inputFilePath === tsconfigPath) {
-    inputFilePath = join(tsconfigPath, 'src');
-  }
-
-  // initialize new Typedoc application
-  const app = new Application();
-  app.options.addReader(new TSConfigReader());
-  app.bootstrap({
-    entryPoints: [inputFilePath.toString()],
-    excludeExternals: excludeExternals,
-    tsconfig: join(tsconfigPath, 'tsconfig.json'),
-  });
-
-  // get project reflection from input files
-  const result = app.convert();
-
-  if (typeof result === 'undefined') {
-    throw new Error('Project reflection could not be generated.');
-  }
-
-  return result;
-}
-
-/**
- * Check if type is a union type
- *
- * @param type Type to check
- */
-function isUnionType(type: Type): type is UnionType {
-  return type.type === 'union';
-}
-
-/**
- * Check if a type is reference type
- *
- * @param type Type to check
- */
-function isReferenceType(type: Type): type is ReferenceType {
-  return type.type === 'reference';
-}
-
-/**
- * Check if a type is an array type
- *
- * @param type Type to check
- */
-function isArrayType(type: Type): type is ArrayType {
-  return type.type === 'array';
-}
-
-/**
- * Check if a type is an intrinsic type
- *
- * @param type Type to check
- */
-function isIntrinsicType(type: Type): type is IntrinsicType {
-  return type.type === 'intrinsic';
-}
-
-/**
- * Check if a type is a string literal type
- *
- * @param type Type to check
- */
-function isLiteralType(type: Type): type is LiteralType {
-  return type.type === 'literal';
-}
-
-/**
- * Get extended types of a declaration reflection
- * @param thingReflection Reflection of the thing
- * @param objects Map of reflections by name
- */
-function getExtendedTypes(thingReflection: DeclarationReflection,
-                          objects: { [name: string]: DeclarationReflection }): string[] {
-  const extendedTypes: string[] = [];
-
-  if (Array.isArray(thingReflection.extendedTypes)) {
-    const typesToCheck = thingReflection.extendedTypes.slice();
-
-    while (typesToCheck.length > 0) {
-      const extendedType = typesToCheck.splice(0, 1)[0];
-
-      extendedTypes.push((extendedType as unknown as ReferenceType).name);
-
-      const extendedObject = objects[(extendedType as unknown as ReferenceType).name];
-
-      if (typeof extendedObject !== 'undefined') {
-        if (Array.isArray(extendedObject.extendedTypes)) {
-          typesToCheck.push.apply(typesToCheck, extendedObject.extendedTypes);
-        }
-      }
-    }
-  }
-
-  return extendedTypes;
-}
 
 @suite(timeout(15000), slow(10000))
 export class SchemaSpec {
-  static objects: { [name: string]: DeclarationReflection } = {};
-  static reflection: ProjectReflection;
-  static thingNames: string[];
-
-  static before() {
-    SchemaSpec.reflection = getProjectReflection(resolve(__dirname, '..', 'src'));
-
-    if (Array.isArray(SchemaSpec.reflection.children)) {
-      for (const module of SchemaSpec.reflection.children) {
-        if (Array.isArray(module.children)) {
-          for (const object of module.children) {
-            SchemaSpec.objects[object.name] = object;
-          }
-        }
-      }
-    }
-
-    const thingsReflection = SchemaSpec.objects.SCIndexableThings;
-
-    // tslint:disable-next-line:no-unused-expression
-    expect(thingsReflection).not.to.be.undefined;
-
-    // tslint:disable-next-line:no-unused-expression
-    expect(isUnionType(thingsReflection.type!)).to.be.true;
-
-    (thingsReflection.type! as UnionType).types.push({
-      'id': 0,
-      'name': 'SCDiff',
-      'type': 'reference',
-    } as unknown as ReferenceType);
-
-    // tslint:disable-next-line:no-unused-expression
-    expect((thingsReflection.type! as UnionType).types.every(isReferenceType)).to.be.true;
-
-    SchemaSpec.thingNames = (thingsReflection.type! as UnionType).types.map((type) => {
-      return (type as ReferenceType).name;
-    });
-  }
-
-  @test
-  'all things have an origin'() {
-    for (const thingName of SchemaSpec.thingNames) {
-      const thingReflection = SchemaSpec.objects[`${thingName}`];
-
-      let originFound = false;
-
-      if (Array.isArray(thingReflection.children)) {
-        for (const property of thingReflection.children) {
-          if (property.name === 'origin') {
-            originFound = true;
-            break;
-          }
-        }
-      }
-
-      // tslint:disable-next-line:no-unused-expression
-      expect(originFound).to.be.equal(true, `'${thingName}' must have property 'origin'.`);
-    }
-  }
-
-  @test
-  'does not have duplicate names'() {
-    const names: string[] = [];
-
-    if (Array.isArray(SchemaSpec.reflection.children)) {
-      for (const module of SchemaSpec.reflection.children) {
-        if (Array.isArray(module.children)) {
-          for (const object of module.children) {
-            expect(names).not.to.contain(object.name);
-            names.push(object.name);
-          }
-        }
-      }
-    }
-  }
-
-  @test
-  'no property is an SCThing'() {
-    const handleUnionType = (type: UnionType, thingName: string, property: DeclarationReflection) => {
-      for (const nestedType of type.types) {
-        if (isIntrinsicType(nestedType) || isLiteralType(nestedType)) {
-          continue;
-        } else if (isReferenceType(nestedType)) {
-          expect(SchemaSpec.thingNames).not.to.contain(
-            nestedType.name,
-            `Union property '${property.name}' on type '${thingName}' contains type '${nestedType.name}'.`,
-          );
-        } else {
-          // tslint:disable-next-line:max-line-length
-          fail(`'${thingName}'#'${property.name}' union type '${nestedType.type}' is not handled by this test!`);
-        }
-      }
-    }
-
-    for (const thingName of SchemaSpec.thingNames) {
-      const thingReflection = SchemaSpec.objects[`${thingName}`];
-
-      if (Array.isArray(thingReflection.children)) {
-        for (const property of thingReflection.children) {
-          if (typeof property.type === 'undefined') {
-            Logger.error(thingName, property.name);
-            continue;
-          }
-
-          let type = property.type!;
-
-          if (isIntrinsicType(type)) {
-            continue;
-          } else if (isArrayType(type)) {
-            const elementType = type.elementType;
-
-            if (isIntrinsicType(elementType) || isLiteralType(elementType)) {
-              continue;
-            } else if (isUnionType(elementType)) {
-              handleUnionType(elementType, thingName, property);
-            } else if (isReferenceType(elementType)) {
-              expect(SchemaSpec.thingNames).not.to.contain(
-                elementType.name,
-                `Array property '${property.name}' on type '${thingName}' has element type '${elementType.name}'.`,
-              );
-            } else {
-              // tslint:disable-next-line:max-line-length
-              fail(`'${thingName}'#'${property.name}' element type '${elementType.type}' is not handled by this test!`);
-            }
-          } else if (isReferenceType(type)) {
-            do {
-              expect(SchemaSpec.thingNames).not.to.contain(
-                type.name,
-                `Property '${property.name}' on type '${thingName}' has element type '${type.name}'.`,
-              );
-
-              const referencedObject = SchemaSpec.objects[type.name];
-              if (typeof referencedObject !== 'undefined') {
-                const referencedType = referencedObject.type;
-                if (typeof referencedType !== 'undefined') {
-                  type = referencedType;
-                } else {
-                  break;
-                }
-              } else {
-                break;
-              }
-            } while (isReferenceType(type));
-          } else if (isUnionType(type)) {
-            handleUnionType(type, thingName, property);
-          } else {
-            // tslint:disable-next-line:max-line-length
-            fail(`'${thingName}'#'${property.name}' with type '${type.type}' is not handled by this test!`);
-          }
-        }
-      }
-    }
-  }
-
-  @test
-  'things extend SCThing'() {
-    for (const thingName of SchemaSpec.thingNames) {
-      const thingReflection = SchemaSpec.objects[`${thingName}`];
-
-      expect(getExtendedTypes(thingReflection, SchemaSpec.objects)).to.contain(
-        'SCThing',
-        `'${thingName}' neither extends 'SCThing' transitively nor directly.`,
-      );
-    }
-  }
-
-  @test
-  'things without references do not extend SCThing'() {
-    for (const thingName of SchemaSpec.thingNames) {
-      const thingWithoutReferencesReflection = SchemaSpec.objects[`${thingName}WithoutReferences`];
-
-      expect(getExtendedTypes(thingWithoutReferencesReflection, SchemaSpec.objects)).not.to.contain(
-        'SCThing',
-        `'${thingName}WithoutReferences' extends 'SCThing' either transitively or directly.`,
-      );
-    }
-  }
-
   @test
   async 'validate against test files'() {
-    const errorsPerFile = await validateFiles(resolve('lib', 'schema'), resolve('test', 'resources'));
+    const errorsPerFile = {
+      ...await validateFiles(resolve('lib', 'schema'), resolve('test', 'resources')),
+      ...await validateFiles(resolve('lib', 'schema'), resolve('test', 'resources', 'indexable')),
+    };
 
     let unexpected = false;
     Object.keys(errorsPerFile).forEach((file) => {

tslint.json

@@ -1,6 +1,7 @@
 {
   "extends": "./node_modules/@openstapps/configuration/tslint.json",
   "rules": {
-    "no-empty-interface": false
+    "no-empty-interface": false,
+    "no-redundant-jsdoc": false
   }
 }