@shakerquiz/utilities 0.2.26 → 0.2.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shakerquiz/utilities",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "author": "yurkimus <yurkimus@gmail.com>",
   "license": "ISC",
   "exports": {
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "@yurkimus/cookies": "0.0.8",
-    "@yurkimus/errors": "0.1.3",
+    "@yurkimus/errors": "0.1.4",
     "@yurkimus/message": "0.0.14",
     "@yurkimus/response-status": "0.1.1",
     "@yurkimus/url": "0.2.8",

package/source/enumerations/cookies.js

@@ -1,5 +1,5 @@
-export var Cookies = {
+export var Cookies = /** @type {const} */ ({
   Token: 'shaker-quiz-token',
   Refresh: 'shaker-quiz-refresh-token',
   Role: 'shaker-quiz-user-role',
-}
+})

package/source/enumerations/features.js

@@ -2,6 +2,7 @@ import { Kinds } from './kinds.js'
 import { Methods } from './methods.js'
 import { Networks } from './networks.js'
 import { Requirements } from './requirements.js'
+import { Services } from './services.js'
 
 export var Features = /** @type {const} */ ({
   Checkin: 'Checkin',
@@ -19,6 +20,22 @@ export var Features = /** @type {const} */ ({
   Users: 'Users',
 })
 
+export var FeatureServices = {
+  [Features.Game]: Services.Games,
+  [Features.Games]: Services.Games,
+  [Features.Theme]: Services.Games,
+  [Features.Themes]: Services.Games,
+  [Features.Registration]: Services.Games,
+  [Features.Registrations]: Services.Games,
+  [Features.Cities]: Services.Locations,
+  [Features.City]: Services.Locations,
+  [Features.Location]: Services.Locations,
+  [Features.Locations]: Services.Locations,
+  [Features.Checkin]: Services.Users,
+  [Features.User]: Services.Users,
+  [Features.Users]: Services.Users,
+}
+
 export var FeatureKinds = {
   [Features.Checkin]: Kinds.Item,
   [Features.Cities]: Kinds.List,
@@ -93,69 +110,14 @@ export var FeaturePatterns = {
   }),
 }
 
-export var FeatureNetworkOrigins = /** @type {const} */ ({
+export var FeatureMethodRequirements = {
   [Features.Checkin]: {
-    [Networks.Private]: 'http://users:8000/',
-    [Networks.Public]: 'https://users.backend.shakerquiz.ru/',
-  },
-  [Features.Cities]: {
-    [Networks.Private]: 'http://locations:8000/',
-    [Networks.Public]: 'https://locations.backend.shakerquiz.ru/',
-  },
-  [Features.City]: {
-    [Networks.Private]: 'http://locations:8000/',
-    [Networks.Public]: 'https://locations.backend.shakerquiz.ru/',
-  },
-  [Features.Game]: {
-    [Networks.Private]: 'http://games:8000/',
-    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
-  },
-  [Features.Games]: {
-    [Networks.Private]: 'http://games:8000/',
-    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
-  },
-  [Features.Location]: {
-    [Networks.Private]: 'http://locations:8000/',
-    [Networks.Public]: 'https://locations.backend.shakerquiz.ru/',
-  },
-  [Features.Locations]: {
-    [Networks.Private]: 'http://locations:8000/',
-    [Networks.Public]: 'https://locations.backend.shakerquiz.ru/',
-  },
-  [Features.Registration]: {
-    [Networks.Private]: 'http://games:8000/',
-    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
-  },
-  [Features.Registrations]: {
-    [Networks.Private]: 'http://games:8000/',
-    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
-  },
-  [Features.Theme]: {
-    [Networks.Private]: 'http://games:8000/',
-    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
-  },
-  [Features.Themes]: {
-    [Networks.Private]: 'http://games:8000/',
-    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
-  },
-  [Features.User]: {
-    [Networks.Private]: 'http://users:8000/',
-    [Networks.Public]: 'https://users.backend.shakerquiz.ru/',
-  },
-  [Features.Users]: {
-    [Networks.Private]: 'http://users:8000/',
-    [Networks.Public]: 'https://users.backend.shakerquiz.ru/',
-  },
-})
-
-export var FeatureRequirements = {
-  [Features.Checkin]: {
-    [Methods.DELETE]: new Set([Requirements.Checkin]),
+    [Methods.DELETE]: new Set([]),
     [Methods.GET]: new Set([]),
     [Methods.OPTIONS]: new Set([]),
-    [Methods.PATCH]: new Set([Requirements.Checkin, Requirements.Body]),
-    [Methods.POST]: new Set([Requirements.Checkin, Requirements.Body]),
-    [Methods.PUT]: new Set([Requirements.Checkin, Requirements.Body]),
+    [Methods.PATCH]: new Set([]),
+    [Methods.POST]: new Set([Requirements.Body]),
+    [Methods.PUT]: new Set([]),
   },
   [Features.Cities]: {
     [Methods.DELETE]: new Set([Requirements.Checkin]),
@@ -254,3 +216,110 @@ export var FeatureRequirements = {
     [Methods.PUT]: new Set([Requirements.Checkin, Requirements.Body]),
   },
 }
+
+export var FeatureNetworkOrigins = new Map([
+  [
+    Features.Checkin,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Cities,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.City,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Game,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Games,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Location,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Locations,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Registration,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Registrations,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Theme,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Themes,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.User,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+  [
+    Features.Users,
+    new Map([
+      [Networks.Docker, ''],
+      [Networks.Local, ''],
+      [Networks.Public, ''],
+    ]),
+  ],
+])

package/source/enumerations/networks.js

@@ -1,4 +1,5 @@
 export var Networks = /** @type {const} */ ({
-  Private: 'Private',
+  Docker: 'Private',
+  Local: 'Local',
   Public: 'Public',
 })

package/source/enumerations/phases.js

@@ -1,7 +1,7 @@
-export let Phases = {
+export var Phases = /** @type {const} */ ({
   Aborted: 'Aborted',
   Failed: 'Failed',
   Idle: 'Idle',
   Loaded: 'Loaded',
   Loading: 'Loading',
-}
+})

package/source/enumerations/regexps.js

@@ -1,4 +1,4 @@
-export let RegExps = {
+export var RegExps = {
   Uuid: /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/,
   ElementId:
     /\d+:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:\d+/,

package/source/enumerations/services.js

@@ -0,0 +1,29 @@
+import { Features } from './features.js'
+
+export var Services = /** @type {const} */ ({
+  Games: 'Games',
+  Locations: 'Locations',
+  Users: 'Users',
+})
+
+export var ServiceFeatures = {
+  [Services.Games]: [
+    Features.Game,
+    Features.Games,
+    Features.Theme,
+    Features.Themes,
+    Features.Registration,
+    Features.Registrations,
+  ],
+  [Services.Locations]: [
+    Features.Cities,
+    Features.City,
+    Features.Location,
+    Features.Locations,
+  ],
+  [Services.Users]: [
+    Features.Checkin,
+    Features.User,
+    Features.Users,
+  ],
+}

package/source/functions/fetch.js

@@ -56,7 +56,7 @@ let request = (feature, method, network, options, init) => {
 
   let instance = new Request(
     url(
-      FeatureNetworkOrigins[feature][network],
+      FeatureNetworkOrigins.get(feature).get(network),
       FeaturePathnames[feature],
       options,
     ),
@@ -113,16 +113,19 @@ export let useFetch = (feature, method, network) => {
       `Feature '${feature}' must be listed in 'FeaturePathnames'.`,
     )
 
-  if (!(feature in FeatureNetworkOrigins))
+  if (!FeatureNetworkOrigins.has(feature))
     throw TypeError(
       `Feature '${feature}' must be listed in 'FeatureNetworkOrigins'.`,
     )
 
-  if (!(network in FeatureNetworkOrigins[feature]))
+  if (!FeatureNetworkOrigins.get(feature).has(network))
     throw TypeError(
-      `Network '${
-        FeatureNetworkOrigins[feature]
-      }' must be listed in 'FeatureNetworkOrigins[feature]'.`,
+      `Feature Network '${feature}' '${network}' must be listed in 'FeatureNetworkOrigins'.`,
+    )
+
+  if (!URL.canParse(FeatureNetworkOrigins.get(feature).get(network)))
+    throw TypeError(
+      `Value of 'FeatureNetworkOrigins' '${feature}' '${network}' cannot be parsed as URL.`,
     )
 
   /**

package/source/functions/origins.js

@@ -0,0 +1,39 @@
+import { FeatureNetworkOrigins, Features } from '../enumerations/features.js'
+import { Networks } from '../enumerations/networks.js'
+import { ServiceFeatures, Services } from '../enumerations/services.js'
+
+/**
+ * @param {Record<
+ *  keyof typeof Services,
+ *  Record<keyof typeof Networks, URL['origin']>
+ * >} origins
+ *
+ * @returns {void}
+ */
+export var setFeatureNetworkOrigins = origins => {
+  for (let service in origins) {
+    if (!(service in Services))
+      throw TypeError(
+        `Service '${service}' must be listed in 'Services'.`,
+      )
+
+    for (let feature of ServiceFeatures[service]) {
+      if (!(feature in Features))
+        throw TypeError(
+          `Feature '${feature}' must be listed in 'Features'.`,
+        )
+
+      for (let network in origins[service]) {
+        if (!(network in Networks))
+          throw TypeError(
+            `Network '${network}' must be listed in 'Networks'.`,
+          )
+
+        return void FeatureNetworkOrigins
+          .get(feature)
+          .get(network)
+          .set(origins[service][network])
+      }
+    }
+  }
+}