@shakerquiz/utilities 0.2.17 → 0.2.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shakerquiz/utilities",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "author": "yurkimus <yurkimus@gmail.com>",
   "license": "ISC",
   "exports": {

package/source/enumerations/constants.js

@@ -1,6 +1,6 @@
-export let Constants = {
+export var Constants = /** @type {const} */ ({
   /**
    * @see https://www.rfc-editor.org/rfc/rfc9562.html#name-nil-uuid
    */
   NilUuid: '00000000-0000-0000-0000-000000000000',
-}
+})

package/source/enumerations/cookies.js

@@ -1,4 +1,4 @@
-export let Cookies = {
+export var Cookies = {
   Token: 'shaker-quiz-token',
   Refresh: 'shaker-quiz-refresh-token',
   Role: 'shaker-quiz-user-role',

package/source/enumerations/features.js

@@ -1,70 +1,147 @@
 import { Kinds } from './kinds.js'
-import { Services } from './services.js'
+import { Networks } from './networks.js'
 
-export let Features = /** @type {const} */ ({
+export var Features = /** @type {const} */ ({
   Checkin: 'Checkin',
-
-  User: 'User',
-  Users: 'Users',
-
-  Theme: 'Theme',
-  Themes: 'Themes',
-
+  Cities: 'Cities',
+  City: 'City',
   Game: 'Game',
   Games: 'Games',
-
-  Registration: 'Registration',
-  Registrations: 'Registrations',
-
-  City: 'City',
-  Cities: 'Cities',
-
   Location: 'Location',
   Locations: 'Locations',
+  Registration: 'Registration',
+  Registrations: 'Registrations',
+  Theme: 'Theme',
+  Themes: 'Themes',
+  User: 'User',
+  Users: 'Users',
 })
 
-export let FeatureKinds = {
+export var FeatureKinds = {
   [Features.Checkin]: Kinds.Item,
-
-  [Features.User]: Kinds.Item,
-  [Features.Users]: Kinds.List,
-
-  [Features.Theme]: Kinds.Item,
-  [Features.Themes]: Kinds.List,
-
+  [Features.Cities]: Kinds.List,
+  [Features.City]: Kinds.Item,
   [Features.Game]: Kinds.Item,
   [Features.Games]: Kinds.List,
-
-  [Features.Registration]: Kinds.Item,
-  [Features.Registrations]: Kinds.List,
-
-  [Features.City]: Kinds.Item,
-  [Features.Cities]: Kinds.List,
-
   [Features.Location]: Kinds.Item,
   [Features.Locations]: Kinds.List,
+  [Features.Registration]: Kinds.Item,
+  [Features.Registrations]: Kinds.List,
+  [Features.Theme]: Kinds.Item,
+  [Features.Themes]: Kinds.List,
+  [Features.User]: Kinds.Item,
+  [Features.Users]: Kinds.List,
 }
 
-export let FeatureServices = {
-  [Features.Checkin]: Services.Users,
-
-  [Features.User]: Services.Users,
-  [Features.Users]: Services.Users,
-
-  [Features.Theme]: Services.Games,
-  [Features.Themes]: Services.Games,
-
-  [Features.Game]: Services.Games,
-  [Features.Games]: Services.Games,
-
-  [Features.Registration]: Services.Games,
-  [Features.Registrations]: Services.Games,
-
-  [Features.City]: Services.Locations,
-  [Features.Cities]: Services.Locations,
+export var FeaturePathnames = /** @type {const} */ ({
+  [Features.Checkin]: '/checkin',
+  [Features.Cities]: '/cities',
+  [Features.City]: '/city/:city?',
+  [Features.Game]: '/game/:game?',
+  [Features.Games]: '/games',
+  [Features.Location]: '/location/:location?',
+  [Features.Locations]: '/locations',
+  [Features.Registration]: '/registration/:registration?',
+  [Features.Registrations]: '/registrations',
+  [Features.Theme]: '/theme/:theme?',
+  [Features.Themes]: '/themes',
+  [Features.User]: '/user/:user?',
+  [Features.Users]: '/users',
+})
 
-  [Features.Location]: Services.Locations,
-  [Features.Locations]: Services.Locations,
+export var FeaturePatterns = {
+  [Features.Checkin]: new URLPattern({
+    pathname: FeaturePathnames[Features.Checkin],
+  }),
+  [Features.Cities]: new URLPattern({
+    pathname: FeaturePathnames[Features.Cities],
+  }),
+  [Features.City]: new URLPattern({
+    pathname: FeaturePathnames[Features.City],
+  }),
+  [Features.Game]: new URLPattern({
+    pathname: FeaturePathnames[Features.Game],
+  }),
+  [Features.Games]: new URLPattern({
+    pathname: FeaturePathnames[Features.Games],
+  }),
+  [Features.Location]: new URLPattern({
+    pathname: FeaturePathnames[Features.Location],
+  }),
+  [Features.Locations]: new URLPattern({
+    pathname: FeaturePathnames[Features.Locations],
+  }),
+  [Features.Registration]: new URLPattern({
+    pathname: FeaturePathnames[Features.Registration],
+  }),
+  [Features.Registrations]: new URLPattern({
+    pathname: FeaturePathnames[Features.Registrations],
+  }),
+  [Features.Theme]: new URLPattern({
+    pathname: FeaturePathnames[Features.Theme],
+  }),
+  [Features.Themes]: new URLPattern({
+    pathname: FeaturePathnames[Features.Themes],
+  }),
+  [Features.User]: new URLPattern({
+    pathname: FeaturePathnames[Features.User],
+  }),
+  [Features.Users]: new URLPattern({
+    pathname: FeaturePathnames[Features.Users],
+  }),
 }
 
-export let FeatureOrigins = new Map()
+export var FeatureNetworkOrigins = /** @type {const} */ ({
+  [Features.Checkin]: {
+    [Networks.Private]: 'http://users/',
+    [Networks.Public]: 'https://users.backend.shakerquiz.ru/',
+  },
+  [Features.Cities]: {
+    [Networks.Private]: 'http://locations/',
+    [Networks.Public]: 'https://locations.backend.shakerquiz.ru/',
+  },
+  [Features.City]: {
+    [Networks.Private]: 'http://locations/',
+    [Networks.Public]: 'https://locations.backend.shakerquiz.ru/',
+  },
+  [Features.Game]: {
+    [Networks.Private]: 'http://games/',
+    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
+  },
+  [Features.Games]: {
+    [Networks.Private]: 'http://games/',
+    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
+  },
+  [Features.Location]: {
+    [Networks.Private]: 'http://locations/',
+    [Networks.Public]: 'https://locations.backend.shakerquiz.ru/',
+  },
+  [Features.Locations]: {
+    [Networks.Private]: 'http://locations/',
+    [Networks.Public]: 'https://locations.backend.shakerquiz.ru/',
+  },
+  [Features.Registration]: {
+    [Networks.Private]: 'http://games/',
+    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
+  },
+  [Features.Registrations]: {
+    [Networks.Private]: 'http://games/',
+    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
+  },
+  [Features.Theme]: {
+    [Networks.Private]: 'http://games/',
+    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
+  },
+  [Features.Themes]: {
+    [Networks.Private]: 'http://games/',
+    [Networks.Public]: 'https://games.backend.shakerquiz.ru/',
+  },
+  [Features.User]: {
+    [Networks.Private]: 'http://users/',
+    [Networks.Public]: 'https://users.backend.shakerquiz.ru/',
+  },
+  [Features.Users]: {
+    [Networks.Private]: 'http://users/',
+    [Networks.Public]: 'https://users.backend.shakerquiz.ru/',
+  },
+})

package/source/enumerations/game-statuses.js

@@ -1,39 +1,39 @@
 import { Roles } from './roles.js'
 
-export let GameStatuses = {
-  Approved: 'APPROVED',
-  Archive: 'ARCHIVE',
-  Closed: 'CLOSED',
-  Finished: 'FINISHED',
-  Invitation: 'FORINVITES',
-  Moderation: 'MODERATION',
-  Published: 'PUBLISHED',
-  Rejected: 'REJECTED',
-  Reserved: 'IS_RESERVE',
-}
+export var GameStatuses = /** @type {const} */ ({
+  APPROVED: 'APPROVED',
+  ARCHIVE: 'ARCHIVE',
+  CLOSED: 'CLOSED',
+  FINISHED: 'FINISHED',
+  FORINVITES: 'FORINVITES',
+  MODERATION: 'MODERATION',
+  PUBLISHED: 'PUBLISHED',
+  REJECTED: 'REJECTED',
+  IS_RESERVE: 'IS_RESERVE',
+})
 
-export let RoleGameStatuses = {
-  [Roles.Admin]: [
-    GameStatuses.Approved,
-    GameStatuses.Moderation,
-    GameStatuses.Published,
-    GameStatuses.Rejected,
-    GameStatuses.Finished,
-    GameStatuses.Archive,
-    GameStatuses.Invitation,
-    GameStatuses.Reserved,
-    GameStatuses.Closed,
+export var RoleGameStatuses = {
+  [Roles.admin]: [
+    GameStatuses.APPROVED,
+    GameStatuses.MODERATION,
+    GameStatuses.PUBLISHED,
+    GameStatuses.REJECTED,
+    GameStatuses.FINISHED,
+    GameStatuses.ARCHIVE,
+    GameStatuses.FORINVITES,
+    GameStatuses.IS_RESERVE,
+    GameStatuses.CLOSED,
   ],
 
-  [Roles.Organizer]: [
-    GameStatuses.Approved,
-    GameStatuses.Published,
-    GameStatuses.Finished,
-    GameStatuses.Archive,
-    GameStatuses.Invitation,
-    GameStatuses.Reserved,
-    GameStatuses.Closed,
+  [Roles.organizer]: [
+    GameStatuses.APPROVED,
+    GameStatuses.PUBLISHED,
+    GameStatuses.FINISHED,
+    GameStatuses.ARCHIVE,
+    GameStatuses.FORINVITES,
+    GameStatuses.IS_RESERVE,
+    GameStatuses.CLOSED,
   ],
 
-  [Roles.Default]: [],
+  [Roles.default]: [],
 }

package/source/enumerations/kinds.js

@@ -1,4 +1,4 @@
-export let Kinds = /** @type {const} */ ({
+export var Kinds = /** @type {const} */ ({
   Item: 'Item',
   List: 'List',
 })

package/source/enumerations/methods.js

@@ -1,7 +1,8 @@
-export let Methods = /** @type {const} */ ({
+export var Methods = /** @type {const} */ ({
   DELETE: 'DELETE',
   GET: 'GET',
   OPTIONS: 'OPTIONS',
   PATCH: 'PATCH',
   POST: 'POST',
+  PUT: 'PUT',
 })

package/source/enumerations/networks.js

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

package/source/enumerations/regexps.js

@@ -1,8 +1,6 @@
 export let 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+/,
-
   Jwt: /^[A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+\.?[A-Za-z0-9-_.+/=]*$/,
 }

package/source/enumerations/roles.js

@@ -1,5 +1,5 @@
-export let Roles = {
-  Admin: 'admin',
-  Organizer: 'organizer',
-  Default: 'default',
-}
+export var Roles = /** @type {const} */ ({
+  admin: 'admin',
+  organizer: 'organizer',
+  default: 'default',
+})

package/source/functions/{request.js → fetch.js}

@@ -2,15 +2,19 @@ import * as cookies from '@yurkimus/cookies'
 import { MessageError } from '@yurkimus/errors'
 import * as message from '@yurkimus/message'
 import { ResponseStatus } from '@yurkimus/response-status'
+import { url } from '@yurkimus/url'
 
 import { Cookies } from '../enumerations/cookies.js'
 import {
   FeatureKinds,
-  FeatureOrigins,
-  FeatureServices,
+  FeatureNetworkOrigins,
+  FeaturePathnames,
+  Features,
 } from '../enumerations/features.js'
 import { Kinds } from '../enumerations/kinds.js'
-import { FeaturePatterns } from '../enumerations/patterns.js'
+import { Methods } from '../enumerations/methods.js'
+import { Networks } from '../enumerations/networks.js'
+import { Roles } from '../enumerations/roles.js'
 
 let handleMessage = (feature, [response, body]) => {
   switch (response.status) {
@@ -27,28 +31,18 @@ let handleMessage = (feature, [response, body]) => {
           return []
       }
 
-    case 400:
-    case 401:
-    case 403:
-    case 404:
-    case 409:
-    case 415:
-    case 500:
-    case 502:
+    default:
       throw MessageError(
-        body.message,
+        body?.message ?? '',
         ResponseStatus(response.status),
       )
-
-    default:
-      throw body
   }
 }
 
 /**
- * @template {FeaturesUnion} Feature
- * @template {MethodsUnion} Method
- * @template {NetworksUnion} Network
+ * @template {keyof typeof Features} Feature
+ * @template {keyof typeof Methods} Method
+ * @template {keyof typeof Networks} Network
  *
  * @param {Feature} feature
  * @param {Method} method
@@ -56,36 +50,37 @@ let handleMessage = (feature, [response, body]) => {
  * @param {import('@yurkimus/url').URLOptions | undefined} options
  * @param {RequestInit} init
  */
-let makeRequest = (feature, method, network, options, init) => {
+let request = (feature, method, network, options, init) => {
   if (!('method' in init))
     init.method = method
 
-  let url = FeatureOrigins
-    .get(FeatureServices[feature])
-    .get(network)
-    .call(
-      undefined,
-      FeaturePatterns[feature].pathname,
+  let instance = new Request(
+    url(
+      FeatureNetworkOrigins[feature][network],
+      FeaturePathnames[feature],
       options,
-    )
-
-  let request = new Request(url, init)
+    ),
+    init,
+  )
 
-  if (!request.headers.has('Content-Type'))
-    request.headers.set(
+  if (!instance.headers.has('Content-Type'))
+    instance.headers.set(
       'Content-Type',
       'application/json',
     )
 
   if ('cookie' in init)
-    request.headers.set(
+    instance.headers.set(
       'Authorization',
       cookies.read(Cookies.Token, init.cookie),
     )
 
-  return fetch(request)
+  return fetch(instance)
     .then(message.read)
-    .then(handleMessage.bind(undefined, feature))
+    .then(handleMessage.bind(
+      undefined,
+      feature,
+    ))
 }
 
 /**
@@ -94,45 +89,54 @@ let makeRequest = (feature, method, network, options, init) => {
 export let Extensions = new WeakMap()
 
 /**
- * @template {FeaturesUnion} Feature
- * @template {MethodsUnion} Method
- * @template {NetworksUnion} Network
+ * @template {keyof typeof Features} Feature
+ * @template {keyof typeof Methods} Method
+ * @template {keyof typeof Networks} Network
  *
  * @param {Feature} feature
  * @param {Method} method
  * @param {Network} network
  */
-export let useRequest = (feature, method, network) => {
-  if (!(feature in FeatureServices))
+export let useFetch = (feature, method, network) => {
+  if (!(feature in Features))
+    throw TypeError(
+      `Feature '${feature}' must be listed in 'Features'.`,
+    )
+
+  if (!(method in Methods))
     throw TypeError(
-      `Feature '${feature}' must be listed in 'FeatureServices'.`,
+      `Method '${method}' must be listed in 'Methods'.`,
     )
 
-  if (!(feature in FeaturePatterns))
+  if (!(feature in FeaturePathnames))
     throw TypeError(
-      `Feature '${feature}' must be listed in 'FeaturePatterns'.`,
+      `Feature '${feature}' must be listed in 'FeaturePathnames'.`,
     )
 
-  if (!FeatureOrigins.has(FeatureServices[feature]))
+  if (!(feature in FeatureNetworkOrigins))
     throw TypeError(
-      `Service '${
-        FeatureServices[feature]
-      }' must be listed in 'FeatureOrigins'.`,
+      `Feature '${feature}' must be listed in 'FeatureNetworkOrigins'.`,
     )
 
-  if (!FeatureOrigins.get(FeatureServices[feature]).has(network))
+  if (!(network in FeatureNetworkOrigins[feature]))
     throw TypeError(
-      `Network '${network}' must be listed in '${FeatureServices[feature]}'.`,
+      `Network '${
+        FeatureNetworkOrigins[feature]
+      }' must be listed in 'FeatureNetworkOrigins[feature]'.`,
     )
 
   /**
+   * @template {keyof typeof Roles} Role
+   *
    * @param {import('@yurkimus/url').URLOptions} options
    * @param {RequestInit} init
+   *
+   * @returns {Promise<FetchResults[Feature][Method][Role]>}
    */
-  let request = (options, init) => {
+  let fetch = (options, init) => {
     let onbefore = parameters => {
       let predicates = Extensions
-        .get(request)
+        .get(fetch)
         .get('onbefore')
 
       return (predicates.size > 0)
@@ -147,7 +151,7 @@ export let useRequest = (feature, method, network) => {
 
     let onfulfilled = contract => {
       let predicates = Extensions
-        .get(request)
+        .get(fetch)
         .get('onfulfilled')
 
       return (predicates.size > 0)
@@ -162,7 +166,7 @@ export let useRequest = (feature, method, network) => {
 
     let onrejected = reason => {
       let predicates = Extensions
-        .get(request)
+        .get(fetch)
         .get('onrejected')
 
       Array
@@ -180,7 +184,7 @@ export let useRequest = (feature, method, network) => {
       }
     })
       .then(([options, init]) =>
-        makeRequest(
+        request(
           feature,
           method,
           network,
@@ -193,7 +197,7 @@ export let useRequest = (feature, method, network) => {
   }
 
   Extensions.set(
-    request,
+    fetch,
     new Map([
       ['onbefore', new Set([])],
       ['onfulfilled', new Set([])],
@@ -201,5 +205,5 @@ export let useRequest = (feature, method, network) => {
     ]),
   )
 
-  return request
+  return fetch
 }