@nymphjs/server 1.0.0-beta.5 → 1.0.0-beta.51

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,8 +36,16 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
     '$testMethodStateless',
     '$testMethod',
     '$throwError',
+    '$throwHttpError',
+    '$throwHttpErrorWithDescription',
+  ];
+  public static clientEnabledStaticMethods = [
+    'testStatic',
+    'testStaticIterable',
+    'testStaticIterableAbort',
+    'throwErrorStatic',
+    'throwErrorStaticIterable',
   ];
-  public static clientEnabledStaticMethods = ['testStatic', 'throwErrorStatic'];
   protected $protectedTags = ['employee'];
   protected $allowlistTags? = ['boss', 'bigcheese'];
   protected $allowlistData? = [
@@ -54,36 +64,34 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
   ];
 
   static async factory(
-    guid?: string
+    guid?: string,
   ): Promise<EmployeeModel & EmployeeModelData> {
     return (await super.factory(guid)) as EmployeeModel & EmployeeModelData;
   }
 
-  static factorySync(guid?: string): EmployeeModel & EmployeeModelData {
-    return super.factorySync(guid) as EmployeeModel & EmployeeModelData;
+  static factorySync(): EmployeeModel & EmployeeModelData {
+    return super.factorySync() as EmployeeModel & EmployeeModelData;
   }
 
-  constructor(guid?: string) {
-    super(guid);
+  constructor() {
+    super();
 
-    if (this.guid == null) {
-      this.$addTag('employee');
-      this.$data.current = true;
-      this.$data.startDate = Date.now();
-      this.$data.subordinates = [];
-      if (!IS_MANAGER) {
-        this.$privateData.push('salary');
-      }
+    this.$addTag('employee');
+    this.$data.current = true;
+    this.$data.startDate = Date.now();
+    this.$data.subordinates = [];
+    if (!IS_MANAGER) {
+      this.$privateData.push('salary');
     }
   }
 
   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) {
@@ -113,14 +121,45 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
     return value * 2;
   }
 
+  public static *testStaticIterable(value: number) {
+    yield value + 1;
+    yield value + 2;
+    yield value + 3;
+  }
+
+  public static *testStaticIterableAbort(): Iterator<number, void, boolean> {
+    let aborted = yield 1;
+
+    if (!aborted) {
+      throw new Error(
+        "testStaticIterableAbort wasn't aborted after the first iteration.",
+      );
+    }
+  }
+
   public static throwErrorStatic() {
     throw new BadFunctionCallError('This function only throws errors.');
   }
 
+  public static *throwErrorStaticIterable() {
+    yield 1;
+    throw new BadFunctionCallError(
+      'This function throws errors after the first iteration.',
+    );
+  }
+
   public $throwError() {
     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;
   }
@@ -139,22 +178,20 @@ export class Employee extends Entity<EmployeeData> {
   // The name of the server class
   public static class = 'Employee';
 
-  constructor(guid?: string) {
-    super(guid);
+  constructor() {
+    super();
 
-    if (guid == null) {
-      this.$addTag('employee');
-      this.$data.current = true;
-      this.$data.subordinates = [];
-    }
+    this.$addTag('employee');
+    this.$data.current = true;
+    this.$data.subordinates = [];
   }
 
   static async factory(guid?: string): Promise<Employee & EmployeeData> {
     return (await super.factory(guid)) as Employee & EmployeeData;
   }
 
-  static factorySync(guid?: string): Employee & EmployeeData {
-    return super.factorySync(guid) as Employee & EmployeeData;
+  static factorySync(): Employee & EmployeeData {
+    return super.factorySync() as Employee & EmployeeData;
   }
 
   $testMethod(value: number) {
@@ -169,17 +206,184 @@ 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 testStaticIterable(value: number) {
+    return this.serverCallStaticIterator('testStaticIterable', [value]);
+  }
+
+  static testStaticIterableAbort() {
+    return this.serverCallStaticIterator('testStaticIterableAbort', []);
   }
 
   static throwErrorStatic() {
-    return Employee.serverCallStatic('throwErrorStatic', []);
+    return this.serverCallStatic('throwErrorStatic', []);
+  }
+
+  static throwErrorStaticIterable() {
+    return this.serverCallStaticIterator('throwErrorStaticIterable', []);
   }
 
   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(): RestrictedModel & RestrictedModelData {
+    return super.factorySync() as RestrictedModel & RestrictedModelData;
+  }
+
+  constructor() {
+    super();
+
+    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() {
+    super();
+
+    this.$data.name = '';
+  }
+
+  static async factory(guid?: string): Promise<Restricted & RestrictedData> {
+    return (await super.factory(guid)) as Restricted & RestrictedData;
+  }
+
+  static factorySync(): Restricted & RestrictedData {
+    return super.factorySync() 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(): PubSubDisabledModel & PubSubDisabledModelData {
+    return super.factorySync() as PubSubDisabledModel & PubSubDisabledModelData;
+  }
+
+  constructor() {
+    super();
+
+    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() {
+    super();
+
+    this.$data.name = '';
+  }
+
+  static async factory(
+    guid?: string,
+  ): Promise<PubSubDisabled & PubSubDisabledData> {
+    return (await super.factory(guid)) as PubSubDisabled & PubSubDisabledData;
+  }
+
+  static factorySync(): PubSubDisabled & PubSubDisabledData {
+    return super.factorySync() as PubSubDisabled & PubSubDisabledData;
+  }
+}

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["../../typedoc.base.json"],
+  "entryPoints": ["src/index.ts"]
+}