@01-edu/shared 2.0.4 → 2.0.5

package/hasura-core.js

@@ -0,0 +1,217 @@
+export class HasuraError extends Error {
+  constructor({ extensions, message, ...props }, cause) {
+    super(message, cause)
+    Object.assign(this, props)
+    Object.assign(this, extensions)
+    Error.captureStackTrace?.(this, HasuraError)
+  }
+}
+
+export const initClient = ({ debug, address, log, ...params }) => {
+  log || (log = debug ? console.debug : () => {})
+  const handlers = new Map()
+  const subscribers = new Map()
+
+  const getId = () => {
+    const id = Math.random().toString(36).slice(2)
+    return handlers.has(id) ? getId() : id
+  }
+
+  const rejectAllPending = err => {
+    subscribers.clear() // TODO: store subscribers query and re-trigger them
+    for (const [id, { reject, noCleanup }] of handlers) {
+      noCleanup || activeQueries.delete(id)
+      handlers.delete(id)
+      reject(err)
+    }
+    return err
+  }
+
+  const end = (handler, props = {}) => {
+    props.duration = Date.now() - handler.start
+    props.size = handler.size
+    props.name = handler.query
+    props.id = handler.id
+    log('query', props)
+    handlers.delete(handler.id)
+    handler.noCleanup || activeQueries.delete(handler.id)
+  }
+
+  const messageFail = (handler, payload, id) => {
+    if (!handler) return log('missing-handler', { id, type: 'error' })
+
+    end(handler, { payload, type: 'error' })
+    handlers.delete(id)
+    return handler.reject(
+      new HasuraError(payload.errors[0], debug && { cause: handler.cause }),
+    )
+  }
+
+  const handleMessage = (data, resolve, reject) => {
+    if (data === '{"type":"ka"}') return // ignore keep alive
+
+    const { type, payload, id } = JSON.parse(data)
+    const handler = handlers.get(id)
+    handler && (handler.size += data.length)
+
+    log('raw', data)
+
+    switch (type) {
+      case 'connection_ack': {
+        return resolve(payload)
+      }
+
+      case 'connection_error': {
+        const err = rejectAllPending(new HasuraError({ errors: [payload] }))
+        return reject(err)
+      }
+
+      case 'data': {
+        if (payload.errors) return messageFail(handler, payload, id)
+
+        const sub = subscribers.get(id)
+        if (!sub) {
+          return handler
+            ? (handler.payload = payload)
+            : log('missing-handler', { id, type: 'error' })
+        }
+
+        sub(payload.data)
+        if (handler) {
+          end(handler, { type, payload })
+          handler.resolve()
+        }
+
+        return
+      }
+
+      case 'error': {
+        return messageFail(handler, payload, id)
+      }
+
+      case 'complete': {
+        if (!handler) return
+        end(handler, { type, payload })
+        return handler.resolve(handler.payload?.data)
+      }
+    }
+  }
+
+  const handleFail = (event, type) =>
+    rejectAllPending(
+      new HasuraError({ message: `WebSocket connection ${type}`, event }),
+    )
+
+  let ws = new WebSocket(address, 'graphql-ws')
+  let activeQueries = new Map()
+  const exec = async (id, payload, name, noCleanup) => {
+    await connection
+    const handler = {
+      id,
+      size: 0,
+      query: name,
+      start: Date.now(),
+      noCleanup,
+    }
+    const result = new Promise((resolve, reject) => {
+      handler.resolve = resolve
+      handler.reject = reject
+    })
+    debug && (handler.cause = Error('hasuraClient.exec'))
+    handlers.set(id, handler)
+    activeQueries.set(id, { payload, name })
+    log('start', { id, payload })
+    ws.send(`{"type":"start","id":"${id}","payload":${payload}}`)
+    return result
+  }
+  const runFromString = (payload, name) => exec(getId(), payload, name)
+
+  const subscribeFromString = (sub, payload, name) => {
+    const id = getId()
+    subscribers.set(id, sub)
+
+    return {
+      execution: exec(id, payload, name, true),
+      unsubscribe: () => {
+        subscribers.delete(id)
+        activeQueries.delete(id)
+        log('stop', { id })
+        ws.send(`{"type":"stop","id":"${id}"}`)
+      },
+    }
+  }
+
+  let connected = false
+  const getConnection = async () => {
+    connected = false
+    const { promise, resolve, reject } = Promise.withResolvers()
+    const onError = () => reject(handleFail(undefined, 'failed'))
+    const onClose = event =>
+      reject(handleFail({ code: event.code, reason: event.reason }, 'close'))
+    ws.addEventListener('error', onError, { once: true })
+    ws.addEventListener('close', onClose, { once: true })
+    ws.addEventListener('message', event =>
+      handleMessage(event.data, resolve, reject),
+    )
+    try {
+      await promise
+      return (connected = true)
+    } finally {
+      ws.removeEventListener('error', onError)
+      ws.removeEventListener('close', onClose)
+    }
+  }
+
+  let connection = getConnection()
+
+  const connect = async ({ adminSecret, token, role, headers }) => {
+    const previousActiveQueries = activeQueries
+    const reload = connected
+    if (reload) {
+      ws.close()
+      ws = new WebSocket(address, 'graphql-ws')
+      connection = getConnection()
+      activeQueries = new Map()
+    }
+
+    if (!ws.readyState) {
+      await new Promise(s => ws.addEventListener('open', s, { once: true }))
+    }
+
+    const payload = {
+      headers: adminSecret
+        ? { 'x-hasura-admin-secret': adminSecret, ...headers }
+        : { Authorization: `Bearer ${token}`, ...headers },
+    }
+
+    role && (payload.headers['x-hasura-role'] = role)
+
+    ws.send(JSON.stringify({ type: 'connection_init', payload }))
+
+    reload &&
+      connection.then(() => {
+        // re exec all previous active queries
+        for (const [id, { payload, name }] of previousActiveQueries) {
+          exec(id, payload, name)
+        }
+      })
+
+    return connection
+  }
+
+  if (params.adminSecret || params.token) {
+    connect(params)
+  }
+
+  return {
+    ws,
+    connect,
+    connection,
+    runFromString,
+    subscribeFromString,
+    run: (query, variables) =>
+      runFromString(JSON.stringify({ query, variables })),
+    subscribe: (sub, query, variables) =>
+      subscribeFromString(sub, JSON.stringify({ query, variables })),
+  }
+}

package/hasura-model.js

@@ -0,0 +1,138 @@
+export const buildModel =
+  prepare =>
+  (name, key = 'id', type = 'Int') => {
+    const list = `${key}_list`
+    const insertQuery = prepare(`
+  mutation insert_${name} ($objects: [${name}_insert_input!]!){
+    insert_${name} (objects: $objects) { returning { ${key} } }
+  }`)
+
+    const updateQuery = prepare(`
+  mutation update_${name} ($${key}: ${type}!, $changes: ${name}_set_input!) {
+    update_${name} (where: {${key}: {_eq: $${key}}}, _set: $changes) { affected_rows }
+  }`)
+
+    const updateQueryAll = prepare(`
+  mutation update_${name} ($${list}: [${type}!], $changes: ${name}_set_input!) {
+    update_${name} (where: {${key}: {_in: $${list}}}, _set: $changes) { affected_rows }
+  }`)
+
+    const deleteQuery = prepare(`
+  mutation delete_${name} ($${key}: ${type}!) {
+    delete_${name} (where: {${key}: {_eq: $${key}}}) { affected_rows }
+  }`)
+
+    const deleteQueryAll = prepare(`
+  mutation delete_${name} ($${list}: [${type}!]) {
+    delete_${name} (where: {id: {_in: $${list}} }) { affected_rows }
+  }`)
+
+    const getCountQuery = prepare(`
+  query ${name}_count {
+    ${name}_aggregate { aggregate { count } }
+  }`)
+
+    const getKey = _ => _[key]
+    const updateOne = ({ [key]: _, ...changes }) =>
+      updateQuery({ [key]: _, changes })
+
+    const mutations = {
+      key,
+      list,
+      insertQuery,
+      deleteQuery,
+      updateQuery,
+      updateQueryAll,
+      deleteQueryAll,
+      remove: _ =>
+        Array.isArray(_)
+          ? deleteQueryAll({ [list]: _ })
+          : deleteQuery({ [key]: _ }),
+      update: (changes, _) => {
+        if (!_) return updateOne(changes)
+        return Array.isArray(_)
+          ? updateQueryAll({ changes, [list]: _ })
+          : updateQuery({ changes, [key]: _ })
+      },
+      add: async _ => {
+        const isArray = Array.isArray(_)
+        const result = await insertQuery.all({ objects: isArray ? _ : [_] })
+
+        return isArray
+          ? result[`insert_${name}`].returning.map(getKey)
+          : result[`insert_${name}`].returning[0][key]
+      },
+    }
+
+    return fields => {
+      const oneById = `($${key}: ${type}!) {
+      ${name} (where: {${key}: {_eq: $${key}}} limit: 1) {${key} ${fields}}
+    }`
+
+      const allById = `($${list}: [${type}!]) {
+      ${name} (where: {${key}: {_in: $${list}}}) {${key} ${fields}}
+    }`
+
+      const byWhere = `($where: ${name}_bool_exp!) {
+      ${name} (where: $where) {${key} ${fields}}
+    }`
+
+      const toPaginate = `(
+      $where: ${name}_bool_exp!, $orderBy: ${name}_order_by!, $limit: Int!, $offset: Int!,
+    ) {
+      ${name} ( order_by: [$orderBy] offset: $offset limit: $limit where: $where ) { ${fields} }
+    }`
+
+      const toPaginateWithCount = `(
+      $where: ${name}_bool_exp!, $orderBy: ${name}_order_by!, $limit: Int!, $offset: Int!,
+    ) {
+      ${name} ( order_by: [$orderBy] offset: $offset limit: $limit where: $where ) { ${fields} }
+      ${name}_aggregate (where: $where) { aggregate { count } } 
+    }`
+
+      const selectQuery = prepare(`query ${oneById}`)
+      const selectQueryAll = prepare(`query ${allById}`)
+      const selectQueryWhere = prepare(`query ${byWhere}`)
+      const selectQueryPaginated = prepare(
+        `query get_${name}_paginate ${toPaginate}`,
+      )
+      const selectQueryPaginatedWithCount = prepare(
+        `query get_${name}_with_count ${toPaginateWithCount}`,
+      )
+      const subscribeQuery = prepare(`subscription ${oneById}`)
+      const subscribeQueryAll = prepare(`subscription ${allById}`)
+      const subscribeQueryWhere = prepare(`subscription ${byWhere}`)
+
+      return {
+        ...mutations,
+        selectQuery,
+        selectQueryAll,
+        selectQueryWhere,
+        subscribeQuery,
+        subscribeQueryAll,
+        subscribeQueryWhere,
+        get: _ => {
+          if (Array.isArray(_)) return selectQueryAll({ [list]: _ })
+          return _ && typeof _ === 'object'
+            ? selectQueryWhere({ where: _ })
+            : selectQuery.one(_ && { [key]: _ })
+        },
+        subscribe: (sub, _) => {
+          if (Array.isArray(_)) return subscribeQueryAll(sub, { [list]: _ })
+          return _ && typeof _ === 'object'
+            ? subscribeQueryWhere(sub, { where: _ })
+            : subscribeQuery.one(sub, _ && { [key]: _ })
+        },
+        getCount: async elems => (await getCountQuery(elems)).aggregate.count,
+        getPaginated: selectQueryPaginated,
+        getPaginatedWithCount: async elems => {
+          const elemsWithCount = await selectQueryPaginatedWithCount.all(elems)
+
+          return {
+            [name]: elemsWithCount[name],
+            count: elemsWithCount[`${name}_aggregate`].aggregate.count,
+          }
+        },
+      }
+    }
+  }

package/hasura-prepare.js

@@ -0,0 +1,44 @@
+const get = _ => Object.values(_)[0]
+const getAll = _ => _
+const getOne = _ => Object.values(_)[0][0]
+export const prepare = ({ runFromString, subscribeFromString }, query) => {
+  if (typeof query !== 'string') {
+    throw Error(`Query must be a string but was ${typeof query}`)
+  }
+
+  let [_, type, name] = query.split(/^\s*(\w+)(?:\s+(\w+))?\b/)
+  if (!type) {
+    type = 'query'
+  } else if (!/^(subscription|mutation|query)$/.test(type)) {
+    throw Error(`Invalid query, type must be query, mutation or subscription`)
+  }
+  name || (name = `${type}_${query.split(/{\s*(.+?)\b/)[1]}`)
+  const payload = JSON.stringify({ query })
+  const noVars = payload
+  const base = payload.slice(0, -1)
+  const build = vars => {
+    if (!vars) return noVars
+    if (typeof vars === 'function') {
+      throw Error(
+        'variables should not be functions, verify the order of your parameters',
+      )
+    }
+    const stringified = JSON.stringify(vars)
+    if (stringified === '{}') return noVars
+    return `${base},"variables":${stringified}}`
+  }
+  const map =
+    type === 'subscription'
+      ? mapper => (sub, vars) =>
+          subscribeFromString(value => sub(mapper(value)), build(vars), name)
+      : mapper => async vars => mapper(await runFromString(build(vars), name))
+
+  const run = map(get)
+  run.all = map(getAll)
+  run.one = map(getOne)
+  run.map = map
+  run.query = query
+  return run
+}
+
+export const initPrepare = client => query => prepare(client, query)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@01-edu/shared",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "type": "module",
   "description": "",
   "scripts": {
@@ -13,6 +13,9 @@
     "./attrs.js",
     "./attrs-defs.js",
     "./graph.js",
+    "./hasura-core.js",
+    "./hasura-model.js",
+    "./hasura-prepare.js",
     "./languages.js",
     "./definitions-checker.js",
     "./path.js",
@@ -20,8 +23,12 @@
     "./score.js",
     "./skill-definitions.js",
     "./toolbox.js",
-    "./object-structure.ts"
+    "./object-structure.js",
+    "./qa-utils.js"
   ],
+  "devDependencies": {
+    "esbuild": "^0.25.12"
+  },
   "license": "Fair",
   "bin": {
     "check-defs": "./bin/check-definitions.js"

package/qa-utils.js

@@ -0,0 +1,13 @@
+export const stringifyJSX = value => {
+  if (!value) return ''
+  if (typeof value === 'string') return value
+  if (Array.isArray(value)) return value.map(stringifyJSX).join('')
+  return stringifyJSX(value.props?.children)
+}
+
+export const toTestId = value =>
+  stringifyJSX(value)
+    .toLowerCase()
+    .replace(/([^a-z0-9]+)/g, ' ')
+    .trim()
+    .replaceAll(' ', '-')

package/object-structure.ts

@@ -1,60 +0,0 @@
-export const onboardingTypes = new Set([
-  'onboarding',
-  'piscine-registration',
-  'interview',
-  'games',
-  'administration',
-  'module-registration',
-  'form-step',
-  'sign-step',
-  'upload-step',
-  'contact-validation-step',
-  'avatar-step',
-] as const)
-
-type Extract<T> = [T] extends [Set<infer V>] ? V : never
-
-export const objectTypes = new Set([
-  'module',
-  'piscine',
-  'exam',
-  'raid',
-  'quest',
-  'exercise',
-  'project',
-  'signup',
-  'campus',
-  ...onboardingTypes,
-] as const)
-
-export type ObjectType = Extract<typeof objectTypes>
-export const childTypes = {
-  campus: ['signup', 'onboarding', 'piscine', 'module'],
-  signup: [
-    'form-step',
-    'sign-step',
-    'upload-step',
-    'contact-validation-step',
-    'avatar-step',
-  ],
-  onboarding: [
-    'games',
-    'administration',
-    'interview',
-    'piscine-registration',
-    'module-registration',
-  ],
-  administration: [
-    'form-step',
-    'sign-step',
-    'upload-step',
-    'contact-validation-step',
-    'avatar-step',
-  ],
-  piscine: ['quest', 'exam', 'raid', 'project'],
-  exam: ['exercise'],
-  quest: ['exercise'],
-  module: ['project', 'piscine', 'exam'],
-} as const satisfies Partial<Record<ObjectType, ObjectType[]>>
-
-export type ChildTypes = typeof childTypes