@nymphjs/server 1.0.0-beta.3 → 1.0.0-beta.30

package/src/statusDescriptions.ts

@@ -0,0 +1,68 @@
+/**
+ * HTTP status code to status text map.
+ */
+export const statusDescriptions: { [k: number]: string } = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing',
+  103: 'Early Hints',
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non-Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status',
+  208: 'Already Reported',
+  226: 'IM Used',
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Found',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  306: 'Switch Proxy',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Payload Too Large',
+  414: 'URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: "I'm a teapot",
+  421: 'Misdirected Request',
+  422: 'Unprocessable Entity',
+  423: 'Locked',
+  424: 'Failed Dependency',
+  425: 'Too Early',
+  426: 'Upgrade Required',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  431: 'Request Header Fields Too Large',
+  451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'HTTP Version Not Supported',
+  506: 'Variant Also Negotiates',
+  507: 'Insufficient Storage',
+  508: 'Loop Detected',
+  510: 'Not Extended',
+  511: 'Network Authentication Required',
+};

package/src/testArtifacts.ts

@@ -1,6 +1,8 @@
 import { Entity as EntityServer, EntityInvalidDataError } from '@nymphjs/nymph';
 import { Entity } from '@nymphjs/client';
 
+import { HttpError } from './HttpError';
+
 export type EmployeeBaseData<T> = {
   name?: string;
   id?: number;
@@ -34,6 +36,8 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
     '$testMethodStateless',
     '$testMethod',
     '$throwError',
+    '$throwHttpError',
+    '$throwHttpErrorWithDescription',
   ];
   public static clientEnabledStaticMethods = ['testStatic', 'throwErrorStatic'];
   protected $protectedTags = ['employee'];
@@ -80,10 +84,10 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
   public async $save() {
     // Validate employee data.
     const error = new EntityInvalidDataError('Invalid entity data.');
-    if (this.$data.name == null || this.$data.name == '') {
+    if (this.$data.name == null || this.$data.name === '') {
       error.addField('name');
     }
-    if (this.$data.title == null || this.$data.title == '') {
+    if (this.$data.title == null || this.$data.title === '') {
       error.addField('title');
     }
     if (this.$data.startDate == null) {
@@ -121,6 +125,14 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
     throw new BadFunctionCallError('This function only throws errors.');
   }
 
+  public $throwHttpError() {
+    throw new HttpError('A 501 HTTP error.', 501);
+  }
+
+  public $throwHttpErrorWithDescription() {
+    throw new HttpError('A 512 HTTP error.', 512, 'Some Error');
+  }
+
   public static inaccessibleMethod() {
     return true;
   }
@@ -169,17 +181,183 @@ export class Employee extends Entity<EmployeeData> {
     return this.$serverCall('$throwError', []);
   }
 
+  $throwHttpError() {
+    return this.$serverCall('$throwHttpError', []);
+  }
+
+  $throwHttpErrorWithDescription() {
+    return this.$serverCall('$throwHttpErrorWithDescription', []);
+  }
+
   static testStatic(value: number) {
-    return Employee.serverCallStatic('testStatic', [value]);
+    return this.serverCallStatic('testStatic', [value]);
   }
 
   static throwErrorStatic() {
-    return Employee.serverCallStatic('throwErrorStatic', []);
+    return this.serverCallStatic('throwErrorStatic', []);
   }
 
   static inaccessibleMethod() {
-    return Employee.serverCallStatic('inaccessibleMethod', []);
+    return this.serverCallStatic('inaccessibleMethod', []);
   }
 }
 
-export default Employee;
+export type RestrictedModelData = {
+  name: string;
+};
+
+/**
+ * This class is a test class that extends the Entity class.
+ */
+export class RestrictedModel extends EntityServer<RestrictedModelData> {
+  static ETYPE = 'restricted';
+  static class = 'Restricted';
+
+  public static restEnabled = false;
+
+  static async factory(
+    guid?: string
+  ): Promise<RestrictedModel & RestrictedModelData> {
+    return (await super.factory(guid)) as RestrictedModel & RestrictedModelData;
+  }
+
+  static factorySync(guid?: string): RestrictedModel & RestrictedModelData {
+    return super.factorySync(guid) as RestrictedModel & RestrictedModelData;
+  }
+
+  constructor(guid?: string) {
+    super(guid);
+
+    if (this.guid == null) {
+      this.$data.name = '';
+    }
+  }
+
+  public async $save() {
+    // Validate entity data.
+    const error = new EntityInvalidDataError('Invalid entity data.');
+    if (this.$data.name == null || this.$data.name === '') {
+      error.addField('name');
+    }
+    if (error.getFields().length) {
+      throw error;
+    }
+    return await super.$save();
+  }
+
+  $testMethod(value: string) {
+    return value;
+  }
+
+  public static testStatic(value: number) {
+    return value;
+  }
+}
+
+export type RestrictedData = {
+  name: string;
+};
+
+export class Restricted extends Entity<RestrictedData> {
+  // The name of the server class
+  public static class = 'Restricted';
+
+  constructor(guid?: string) {
+    super(guid);
+
+    if (guid == null) {
+      this.$data.name = '';
+    }
+  }
+
+  static async factory(guid?: string): Promise<Restricted & RestrictedData> {
+    return (await super.factory(guid)) as Restricted & RestrictedData;
+  }
+
+  static factorySync(guid?: string): Restricted & RestrictedData {
+    return super.factorySync(guid) as Restricted & RestrictedData;
+  }
+
+  $testMethod(value: number) {
+    return this.$serverCall('$testMethod', [value]);
+  }
+
+  static testStatic(value: number) {
+    return this.serverCallStatic('testStatic', [value]);
+  }
+}
+
+export type PubSubDisabledModelData = {
+  name: string;
+};
+
+/**
+ * This class is a test class that extends the Entity class.
+ */
+export class PubSubDisabledModel extends EntityServer<PubSubDisabledModelData> {
+  static ETYPE = 'pubsub_disabled';
+  static class = 'PubSubDisabled';
+
+  public static pubSubEnabled = false;
+
+  static async factory(
+    guid?: string
+  ): Promise<PubSubDisabledModel & PubSubDisabledModelData> {
+    return (await super.factory(guid)) as PubSubDisabledModel &
+      PubSubDisabledModelData;
+  }
+
+  static factorySync(
+    guid?: string
+  ): PubSubDisabledModel & PubSubDisabledModelData {
+    return super.factorySync(guid) as PubSubDisabledModel &
+      PubSubDisabledModelData;
+  }
+
+  constructor(guid?: string) {
+    super(guid);
+
+    if (guid == null) {
+      this.$data.name = '';
+    }
+  }
+
+  public async $save() {
+    // Validate entity data.
+    const error = new EntityInvalidDataError('Invalid entity data.');
+    if (this.$data.name == null || this.$data.name === '') {
+      error.addField('name');
+    }
+    if (error.getFields().length) {
+      throw error;
+    }
+    return await super.$save();
+  }
+}
+
+export type PubSubDisabledData = {
+  name: string;
+};
+
+export class PubSubDisabled extends Entity<PubSubDisabledData> {
+  // The name of the server class
+  public static class = 'PubSubDisabled';
+
+  constructor(guid?: string) {
+    super(guid);
+
+    if (guid == null) {
+      this.$data.name = '';
+    }
+  }
+
+  static async factory(
+    guid?: string
+  ): Promise<PubSubDisabled & PubSubDisabledData> {
+    return (await super.factory(guid)) as PubSubDisabled & PubSubDisabledData;
+  }
+
+  static factorySync(guid?: string): PubSubDisabled & PubSubDisabledData {
+    return super.factorySync(guid) as PubSubDisabled & PubSubDisabledData;
+  }
+}