@shakerquiz/utilities 4.0.53 → 4.0.54

package/dprint.json

@@ -18,4 +18,4 @@
     "https://plugins.dprint.dev/typescript-0.93.0.wasm",
     "https://plugins.dprint.dev/json-0.19.3.wasm"
   ]
-}
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@shakerquiz/utilities",
-  "version": "4.0.53",
+  "version": "4.0.54",
   "author": "yurkimus <yurkimus@gmail.com>",
   "license": "ISC",
   "repository": {

package/scripts/codegen.js

@@ -30,7 +30,7 @@ let breakdown = route =>
       else if (Segment[x].cardinality === '1')
         return x
       else
-        return Segment[x].relation
+        return Segment[x].singular
     })
     .join('/')
 
@@ -45,7 +45,7 @@ let relation = route => {
 
   return segments
     .slice(segments.length >= 3 ? -2 : 0)
-    .map(x => Segment[x].cardinality === '1' ? x : Segment[x].relation)
+    .map(x => Segment[x].cardinality === '1' ? x : Segment[x].singular)
     .join('/')
 }
 

package/source/entities/segment.js

@@ -1,4 +1,3 @@
-import { Key } from './key.js'
 import { Pattern } from './pattern.js'
 import { Service } from './services.js'
 
@@ -6,371 +5,422 @@ export const Segments = Object.freeze(
   /** @type {const} */ ([
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['checkin'],
+        key: 'checkin',
         cardinality: '1',
-        relation: undefined,
+        singular: 'checkin',
+        plural: 'checkins',
         service: Service['Checkin'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['user'],
+        key: 'user',
         cardinality: '1',
-        relation: Key['users'],
+        singular: 'user',
+        plural: 'users',
         service: Service['Users'],
         pattern: Pattern.UUID.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['users'],
+        key: 'users',
         cardinality: 'n',
-        relation: Key['user'],
+        singular: 'user',
+        plural: 'users',
         service: Service['Users'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['role'],
+        key: 'role',
         cardinality: '1',
-        relation: Key['roles'],
+        singular: 'role',
+        plural: 'roles',
         service: Service['Roles'],
         pattern: Pattern.UUID.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['roles'],
+        key: 'roles',
         cardinality: 'n',
-        relation: Key['role'],
+        singular: 'role',
+        plural: 'roles',
         service: Service['Roles'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['country'],
+        key: 'country',
         cardinality: '1',
-        relation: Key['countries'],
+        singular: 'country',
+        plural: 'countries',
         service: Service['Locations'],
         pattern: Pattern.COUNTRY_CODE.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['countries'],
+        key: 'countries',
         cardinality: 'n',
-        relation: Key['country'],
+        singular: 'country',
+        plural: 'countries',
         service: Service['Locations'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['currency'],
+        key: 'currency',
         cardinality: '1',
-        relation: Key['currencies'],
+        singular: 'currency',
+        plural: 'currencies',
         service: Service['Locations'],
         pattern: Pattern.CURRENCY_CODE.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['currencies'],
+        key: 'currencies',
         cardinality: 'n',
-        relation: Key['currency'],
+        singular: 'currency',
+        plural: 'currencies',
         service: Service['Locations'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['timezone'],
+        key: 'timezone',
         cardinality: '1',
-        relation: Key['timezones'],
+        singular: 'timezone',
+        plural: 'timezones',
         service: Service['Locations'],
         pattern: Pattern.TIMEZONE_NAME.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['timezones'],
+        key: 'timezones',
         cardinality: 'n',
-        relation: Key['timezone'],
+        singular: 'timezone',
+        plural: 'timezones',
         service: Service['Locations'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['city'],
+        key: 'city',
         cardinality: '1',
-        relation: Key['cities'],
+        singular: 'city',
+        plural: 'cities',
         service: Service['Cities'],
         pattern: Pattern.UUID.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['cities'],
+        key: 'cities',
         cardinality: 'n',
-        relation: Key['city'],
+        singular: 'city',
+        plural: 'cities',
         service: Service['Cities'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['venue'],
+        key: 'venue',
         cardinality: '1',
-        relation: Key['venues'],
+        singular: 'venue',
+        plural: 'venues',
         service: Service['Venues'],
         pattern: Pattern.UUID.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['venues'],
+        key: 'venues',
         cardinality: 'n',
-        relation: Key['venue'],
+        singular: 'venue',
+        plural: 'venues',
         service: Service['Venues'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['theme'],
+        key: 'theme',
         cardinality: '1',
-        relation: Key['themes'],
+        singular: 'theme',
+        plural: 'themes',
         service: Service['Themes'],
         pattern: Pattern.UUID.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['themes'],
+        key: 'themes',
         cardinality: 'n',
-        relation: Key['theme'],
+        singular: 'theme',
+        plural: 'themes',
         service: Service['Themes'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['cover'],
+        key: 'cover',
         cardinality: '1',
-        relation: undefined,
+        singular: 'cover',
+        plural: 'covers',
         service: Service['Minio'],
         pattern: Pattern.UUID.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['game'],
+        key: 'covers',
+        cardinality: 'n',
+        singular: 'cover',
+        plural: 'covers',
+        service: Service['Minio'],
+        pattern: null,
+      }),
+    ),
+    Object.freeze(
+      /** @type {const} */ ({
+        key: 'game',
         cardinality: '1',
-        relation: Key['games'],
+        singular: 'game',
+        plural: 'games',
         service: Service['Games'],
         pattern: Pattern.UUID.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['games'],
+        key: 'games',
         cardinality: 'n',
-        relation: Key['game'],
+        singular: 'game',
+        plural: 'games',
         service: Service['Games'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['registration'],
+        key: 'registration',
         cardinality: '1',
-        relation: Key['registrations'],
+        singular: 'registration',
+        plural: 'registrations',
         service: Service['Registrations'],
         pattern: Pattern.UUID.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['registrations'],
+        key: 'registrations',
         cardinality: 'n',
-        relation: Key['registration'],
+        singular: 'registration',
+        plural: 'registrations',
         service: Service['Registrations'],
-        pattern: undefined,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['export'],
+        key: 'status',
         cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        singular: 'status',
+        plural: 'statuses',
+        service: null,
+        pattern: Pattern.STRING.source,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['password'],
-        cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        key: 'statuses',
+        cardinality: 'n',
+        singular: 'status',
+        plural: 'statuses',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['vk_group_token'],
+        key: 'lineup',
         cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        singular: 'lineup',
+        plural: 'lineups',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['summary'],
-        cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        key: 'lineups',
+        cardinality: 'n',
+        singular: 'lineup',
+        plural: 'lineups',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['mailing'],
+        key: 'telegram',
         cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        singular: 'telegram',
+        plural: 'telegrams',
+        service: Service['Telegram'],
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['channel'],
+        key: 'chatapp',
         cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        singular: 'chatapp',
+        plural: 'chatapps',
+        service: Service['Chatapp'],
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['status'],
+        key: 'bitrix',
         cardinality: '1',
-        relation: Key['statuses'],
-        service: undefined,
-        pattern: Pattern.STRING.source,
+        singular: 'bitrix',
+        plural: 'bitrixes',
+        service: Service['Bitrix'],
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['statuses'],
-        cardinality: 'n',
-        relation: Key['status'],
-        service: undefined,
-        pattern: undefined,
+        key: 'webhook',
+        cardinality: '1',
+        singular: 'webhook',
+        plural: 'webhooks',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['creation'],
+        key: 'source',
         cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        singular: 'source',
+        plural: 'sources',
+        service: Service['Updates'],
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['confirmation'],
+        key: 'search',
         cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        singular: 'search',
+        plural: 'searches',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['cancellation'],
+        key: 'export',
         cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        singular: 'export',
+        plural: 'exports',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['lineup'],
+        key: 'password',
         cardinality: '1',
-        relation: Key['lineups'],
-        service: undefined,
-        pattern: undefined,
+        singular: 'password',
+        plural: 'passwords',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['lineups'],
-        cardinality: 'n',
-        relation: Key['lineup'],
-        service: undefined,
-        pattern: undefined,
+        key: 'vk_group_token',
+        cardinality: '1',
+        singular: 'vk_group_token',
+        plural: 'vk_group_tokens',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['telegram'],
+        key: 'summary',
         cardinality: '1',
-        relation: undefined,
-        service: Service['Telegram'],
-        pattern: undefined,
+        singular: 'summary',
+        plural: 'summaries',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['chatapp'],
+        key: 'mailing',
         cardinality: '1',
-        relation: undefined,
-        service: Service['Chatapp'],
-        pattern: undefined,
+        singular: 'mailing',
+        plural: 'mailings',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['bitrix'],
+        key: 'channel',
         cardinality: '1',
-        relation: undefined,
-        service: Service['Bitrix'],
-        pattern: undefined,
+        singular: 'channel',
+        plural: 'channels',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['webhook'],
+        key: 'creation',
         cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        singular: 'creation',
+        plural: 'creations',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['source'],
+        key: 'confirmation',
         cardinality: '1',
-        relation: undefined,
-        service: Service['Updates'],
-        pattern: undefined,
+        singular: 'confirmation',
+        plural: 'confirmations',
+        service: null,
+        pattern: null,
       }),
     ),
     Object.freeze(
       /** @type {const} */ ({
-        key: Key['search'],
+        key: 'cancellation',
         cardinality: '1',
-        relation: undefined,
-        service: undefined,
-        pattern: undefined,
+        singular: 'cancellation',
+        plural: 'cancellations',
+        service: null,
+        pattern: null,
       }),
     ),
   ]),

package/source/helpers/route-pathname.js

@@ -1,27 +1,127 @@
-import { PathnameParameters, RoutePathname } from '../codegen/autogenerated.js'
-import { Route } from '../entities/routes.js'
-import { access } from './access.js'
+import { Segment } from '../entities/segment.js'
 
 /**
- * @template {keyof typeof import('@shakerquiz/utilities').Route} R
+ * @param {string} maybeString
  *
- * @param {R} maybeRoute
+ * @example
+ * route('user/role') // 'user/role'
+ * route('game/registrations') // 'game/registrations'
+ */
+export const route = maybeString => {
+  if (typeof maybeString !== 'string')
+    throw TypeError(`Parameter 'maybeString' must be String.`)
+
+  const segments = maybeString.split('/')
+
+  if (segments.length < 1)
+    throw TypeError(`Parameter 'maybeString' must contain at least one segment.`)
+
+  for (const segment of segments)
+    if (!Object.hasOwn(Segment, segment))
+      throw TypeError(`[route] Could not access segment Segment['${segment}'].`)
+
+  return segments.join('/')
+}
+
+/**
+ * @param {string} segment
+ *
+ * @example
+ * segment('user') // 'user/:user'
+ * segment('roles') // 'roles'
+ */
+export const segment = segment => {
+  if (Segment[segment].pattern === null)
+    return segment
+  else if (Segment[segment].cardinality === '1')
+    return `${segment}/:${segment}`
+  else
+    return segment
+}
+
+/**
+ * @param {string} maybeRoute
+ *
+ * @example
+ * routePathname('user/role') // 'user/:user/role/:role'
+ * routePathname('game/registrations') // 'game/:game/registrations'
+ */
+export const routePathname = maybeRoute =>
+  route(maybeRoute)
+    .split('/')
+    .map(segment)
+    .join('/')
+
+/**
+ * @param {string} maybeRoute
+ *
+ * @example
+ * routeParameters('user/role') // [':user', ':role']
+ * routeParameters('game/registrations') // [':game']
+ */
+export const routeParameters = maybeRoute =>
+  routePathname(maybeRoute)
+    .split('/')
+    .filter(x => x.includes(':'))
+
+/**
+ * @param {string} maybeRoute
+ * @param {object} object
+ *
+ * @example
+ * routeParametersFromObject('user/role', { ':user': 1, ':role': 2 }) // [1, 2]
+ * routeParametersFromObject('game/registrations', { ':game': 1 }) // [1]
+ */
+export const routeParametersFromObject = (maybeRoute, object) =>
+  routeParameters(maybeRoute)
+    .map(prop => object[prop])
+    .filter(Boolean)
+
+/**
+ * @param {string} maybeRoute
+ *
+ * @example
+ * routeProperties('user/role') // ['user_id', 'role_id']
+ * routeProperties('game/registrations') // ['game_id']
+ */
+export const routeProperties = maybeRoute =>
+  routeParameters(maybeRoute)
+    .map(parameter => parameter.replace(':', '') + '_id')
+
+/**
+ * @param {string} maybeRoute
+ * @param {object} object
+ *
+ * @example
+ * routePropertiesFromObject('user/role', { user_id: 1, role_id: 2 }) // [1, 2]
+ * routePropertiesFromObject('game/registrations', { game_id: 1 }) // [1]
+ */
+export const routePropertiesFromObject = (maybeRoute, object) =>
+  routeProperties(maybeRoute)
+    .map(prop => object[prop])
+    .filter(Boolean)
+
+/**
+ * @param {string} maybeRoute
  * @param {any[]} maybeParams
  *
- * @returns {typeof import('@shakerquiz/utilities').RoutePathname[R]}
+ * @example
+ * hydrateRoutePathname('user/role', [1, 2]) // 'user/1/role/2'
+ * hydrateRoutePathname('game/registrations', [1]) // 'game/1/registrations'
  */
 export const hydrateRoutePathname = (maybeRoute, maybeParams) => {
   if (!Array.isArray(maybeParams))
-    throw TypeError(`Parameter 'params' must be 'Array'.`)
-
-  var route = access(Route, maybeRoute)
+    throw TypeError(`Parameter 'params' must be Array.`)
 
-  var pathname = access(RoutePathname, route)
+  const pathname = routePathname(maybeRoute)
 
-  var pathnameParameters = access(PathnameParameters, pathname)
+  const parameters = routeParameters(maybeRoute)
 
-  return pathnameParameters.reduce((pathname, parameter, index) =>
-    Object.hasOwn(maybeParams, index)
-      ? pathname.replace(parameter, maybeParams[index])
-      : pathname, pathname)
+  return parameters.reduce(
+    (accumulator, parameter, index) =>
+      Object.hasOwn(maybeParams, index)
+        ? accumulator.replace(parameter, maybeParams[index])
+        : accumulator,
+    pathname,
+  )
 }

package/source/helpers/tag.js

@@ -1,37 +1,36 @@
 import { Method } from '../entities/method.js'
 
-import { access } from './access.js'
 import { hydrateRoutePathname } from './route-pathname.js'
 
 /**
  * @template {keyof typeof  import('@shakerquiz/utilities').Method} M
- * @template {keyof typeof  import('@shakerquiz/utilities').Route} R
  *
  * @param {M} maybeMethod
- * @param {R} maybeRoute
+ * @param {string} maybeRoute
  * @param {any[]} maybeParams
  *
- * @returns {`${M}/${ReturnType<typeof hydrateRoutePathname<R>>}`}
- *
  * @example
  * tag('GET', 'cities', []) // => 'GET/cities'
  *
- * tag('GET', 'game/theme/cover', ['<g>']) // => 'GET/game/<g>/theme/:theme/:cover'
+ * tag('GET', 'game/theme/cover', ['<game>']) // => 'GET/game/<game>/theme/:theme/:cover'
  *
  * tag('POST', 'city', []) // => 'POST/city/:city'
  */
 export const tag = (maybeMethod, maybeRoute, maybeParams) => {
-  var method = access(Method, maybeMethod)
+  if (!Object.hasOwn(Method, maybeMethod))
+    throw TypeError(`Could not access Method['${maybeMethod}'].`)
 
-  return method + '/' + hydrateRoutePathname(maybeRoute, maybeParams)
+  return ''
+    + Method[maybeMethod]
+    + '/'
+    + hydrateRoutePathname(maybeRoute, maybeParams)
 }
 
 /**
  * @template {keyof typeof  import('@shakerquiz/utilities').Method} M
- * @template {keyof typeof  import('@shakerquiz/utilities').Route} R
  *
  * @param {M} maybeMethod
- * @param {R} maybeRoute
+ * @param {string} maybeRoute
  * @param {any[]} maybeParams
  */
 export const tagexp = (maybeMethod, maybeRoute, maybeParams) =>

package/source/index.js

@@ -32,6 +32,5 @@ export * from './entities/theme-status.js'
 export * from './entities/venue-audience.js'
 export * from './entities/venue-status.js'
 export * from './helpers/access.js'
-export * from './helpers/params.js'
 export * from './helpers/route-pathname.js'
 export * from './helpers/tag.js'

package/source/helpers/params.js

@@ -1,17 +0,0 @@
-import { RouteParameters } from '../codegen/autogenerated.js'
-
-/**
- * @param {keyof typeof import('@shakerquiz/utilities').Route} route
- */
-export const props = route =>
-  RouteParameters[route]
-    .map(param => param.replace(':', '') + '_id')
-
-/**
- * @param {keyof typeof import('@shakerquiz/utilities').Route} route
- * @param {object} value
- */
-export const params = (route, value) =>
-  props(route)
-    .map(prop => value[prop])
-    .filter(Boolean)