@pihanga2/core 0.2.0

package/src/rest/types.ts

@@ -0,0 +1,135 @@
+import { RestContentType } from ".."
+import { registerActions } from "../redux"
+import { DispatchF, ReduxAction, ReduxState } from "../types"
+
+export const Domain = "pi/rest"
+export const ACTION_TYPES = registerActions(Domain, [
+  // "GET_SUBMITTED",
+  // "GET_RESULT",
+  // "GET_ERROR",
+  // "GET_INTERNAL_ERROR",
+  // "GET_PERIODIC_TICK",
+  "POST_SUBMITTED",
+  "POST_RESULT",
+  "POST_ERROR",
+  "POST_INTERNAL_ERROR",
+  "PUT_SUBMITTED",
+  "PUT_RESULT",
+  "PUT_ERROR",
+  "PUT_INTERNAL_ERROR",
+  "PATCH_SUBMITTED",
+  "PATCH_RESULT",
+  "PATCH_ERROR",
+  "PATCH_INTERNAL_ERROR",
+  "DELETE_SUBMITTED",
+  "DELETE_RESULT",
+  "DELETE_ERROR",
+  "DELETE_INTERNAL_ERROR",
+  "UNAUTHORISED_ERROR",
+  "PERMISSION_DENIED_ERROR",
+  "NOT_FOUND_ERROR",
+  "ERROR",
+  "CONTEXT_ERROR"
+])
+
+export type Bindings = { [key: string]: string | number }
+export type PoPuPaRequest = {
+  body: any
+  contentType?: string // if not set and body is 'object' then we send it as jsonconst h = {}
+  bindings?: Bindings
+}
+
+export type RegisterGenericProps<
+  S extends ReduxState,
+  A extends ReduxAction,
+  R,
+  C = any,
+> = {
+  name: string
+  origin?: string | ((action: A, state: S, context: C) => string | URL) // if defined, will be prepended to 'url' (URL(window.location.href).origin)
+  url: string
+  trigger: string
+  context?: (action: A, state: S) => Promise<C> | null
+  guard?: (action: A, state: S, dispatcher: DispatchF, context: C) => boolean
+  headers?: (action: A, state: S, context: C) => { [key: string]: string }
+  reply: (
+    state: S,
+    reply: R,
+    dispatcher: DispatchF,
+    result: ResultAction<A>,
+  ) => S
+  error?: (
+    state: S,
+    error: ErrorAction<A>,
+    requestAction: A,
+    dispatch: DispatchF,
+  ) => S
+}
+
+export type PiRegisterGetProps<
+  S extends ReduxState,
+  A extends ReduxAction,
+  R,
+  C = any,
+> = RegisterGenericProps<S, A, R, C> & {
+  request?: (action: A, state: S) => Bindings
+}
+
+export type PiRegisterPoPuPaProps<
+  S extends ReduxState,
+  A extends ReduxAction,
+  R,
+  C = any,
+> = RegisterGenericProps<S, A, R, C> & {
+  request: (action: A, state: S) => PoPuPaRequest
+}
+
+export type PiRegisterDeleteProps<
+  S extends ReduxState,
+  A extends ReduxAction,
+  R,
+  C = any,
+> = RegisterGenericProps<S, A, R, C> & {
+  request?: (action: A, state: S) => Bindings
+}
+
+
+export type HttpResponse = {
+  statusCode: number
+  headers: { [k: string]: any }
+  content: any
+  contentType: RestContentType
+  mimeType: string
+  size: number
+}
+
+export type SubmitAction = ReduxAction & {
+  requestID: string
+  url: string
+  bindings: Bindings
+}
+
+export enum ErrorKind {
+  Unauthorised = "Unauthorised",
+  PermissionDenied = "PermissionDenied",
+  NotFound = "NotFound",
+  Other = "Other",
+}
+
+export type ResultAction<R> = ReduxAction & {
+  queryID: string
+  url: string
+  request: R
+} & HttpResponse
+
+export type ErrorAction<R> = ReduxAction & {
+  requestID: string
+  error: ErrorKind
+  url: string
+  request: R
+} & HttpResponse
+
+export type ContextErrorAction = ReduxAction & {
+  error: string
+  pendingAction: ReduxAction
+}

package/src/rest/utils.ts

@@ -0,0 +1,265 @@
+import { current } from "immer"
+import { DispatchF, PiReducer, ReduxAction, ReduxState } from "../types"
+import {
+  ACTION_TYPES,
+  Bindings,
+  ContextErrorAction,
+  ErrorAction,
+  ErrorKind,
+  HttpResponse,
+  RegisterGenericProps,
+  ResultAction,
+} from "./types"
+import { RestContentType } from "./enums"
+
+export function parseResponse(
+  response: Response,
+): Promise<[any, RestContentType, string, Response]> {
+  const mimeType = response.headers.get("content-type")
+  if (mimeType) {
+    switch (mimeType) {
+      case "application/json":
+        return response.json().then((j) => [j, RestContentType.Object, mimeType, response])
+      case "application/jose":
+        return response.text().then((t) => [t, RestContentType.Text, mimeType, response])
+      default:
+        if (mimeType.startsWith("text")) {
+          return response.text().then((t) => [t, RestContentType.Text, mimeType, response])
+        }
+    }
+  }
+  return response.blob().then((t) => [t, RestContentType.Blob, mimeType || "unknown", response])
+}
+
+export function createErrorAction<R>(
+  type: string,
+  resp: HttpResponse,
+  name: string,
+  url: URL,
+  request: R,
+): ErrorAction<R> {
+  let error: ErrorKind
+  const status = resp.statusCode
+  if (status === 401) {
+    error = ErrorKind.Unauthorised
+  } else if (status === 403) {
+    error = ErrorKind.PermissionDenied
+  } else if (status === 404) {
+    error = ErrorKind.NotFound
+  } else {
+    error = ErrorKind.Other
+  }
+  return {
+    type,
+    requestID: name,
+    error,
+    url: url.toString(),
+    request,
+    ...resp,
+  }
+}
+
+export type RequestF<S extends ReduxState, A extends ReduxAction> = (
+  state: S,
+  action: A,
+) => [RequestInit, Bindings]
+
+export function registerCommon<S extends ReduxState, A extends ReduxAction, R, C = any>(
+  reducer: PiReducer,
+  props: RegisterGenericProps<S, A, R, C>,
+  requestF: RequestF<S, A>,
+  submitType: string,
+  resultType: string,
+  errorType: string,
+  intErrorType: string,
+) {
+  const {
+    name,
+    origin = window.location.href,
+    url,
+    trigger,
+    context,
+    guard,
+    headers,
+    reply,
+    error,
+  } = props
+
+  if (!name) {
+    throw Error('Missing "name"')
+  }
+  if (!url) {
+    throw Error('Missing "url"')
+  }
+  if (!trigger) {
+    throw Error('Missing "trigger"')
+  }
+  if (!reply) {
+    throw Error('Missing "reply"')
+  }
+
+  reducer.register<S, A>(
+    trigger,
+    (state: S, action: A, dispatch: DispatchF) => {
+      const ctxtP = context ? context(action, state) : null
+      if (ctxtP) {
+        // const s = current(state) // need
+        ctxtP
+          .then((ctxt) => handleEvent(null as unknown as S, action, dispatch, ctxt))
+          .catch((err) => {
+            const a: ContextErrorAction = {
+              type: ACTION_TYPES.CONTEXT_ERROR,
+              error: err.toString(),
+              pendingAction: action
+            }
+            dispatch(a)
+          })
+      } else {
+        // we should remove state as argument
+        handleEvent(null as unknown as S, action, dispatch, {} as any)
+      }
+      return state
+    })
+
+  function handleEvent(state: S, action: A, dispatch: DispatchF, ctxt: C): S {
+    if (guard) {
+      if (!guard(action, state, dispatch, ctxt)) {
+        return state
+      }
+    }
+    let bindings: Bindings = {}
+    let request: RequestInit
+    let url2: URL
+    try {
+      ;[request, bindings] = requestF(state, action)
+      if (headers) {
+        const h = headers(action, state, ctxt)
+        request.headers = request.headers ? { ...request.headers, ...h } : h
+      }
+      let o: string
+      if (typeof origin === "function") {
+        const ox = origin(action, state, ctxt)
+        o = ox instanceof URL ? ox.toString() : ox
+      } else {
+        o = origin
+      }
+      url2 = buildURL(url, o, bindings)
+    } catch (e: any) {
+      dispatch({
+        type: intErrorType,
+        error: e?.message,
+        call: name,
+        action,
+        bindings,
+      })
+      return state
+    }
+
+    dispatch({
+      type: submitType,
+      requestID: name,
+      url: url2.toString(),
+      bindings,
+    })
+    _fetch(url2, request)
+      .then((resp) => {
+        if (resp.statusCode < 300) {
+          const a: ResultAction<A> = {
+            type: resultType,
+            queryID: name,
+            ...resp,
+            url: url2.toString(),
+            request: action,
+          }
+          dispatch(a)
+        } else {
+          const a = createErrorAction(errorType, resp, name, url2, action)
+          dispatch(a)
+        }
+      })
+      .catch((error) => console.log("_fetch", error))
+    return state
+  }
+
+  reducer.register<S, ResultAction<A>>(resultType, (state, ra, dispatch) => {
+    return reply(state, ra.content, dispatch, ra)
+  })
+
+  if (error) {
+    reducer.register<S, ErrorAction<A>>(
+      errorType,
+      (state, action, dispatch) => {
+        return error(state, action, action.request, dispatch)
+      },
+    )
+  }
+}
+
+function buildURL(url: string, origin: string, bindings: Bindings): URL {
+  const u = new URL(url, origin)
+  u.pathname = u.pathname
+    .split("/")
+    .map((p) => {
+      return resolveBinding(p, bindings, encodeURIComponent)
+    })
+    .join("/")
+  if (u.search !== "") {
+    const params = new URLSearchParams()
+    u.searchParams.forEach((v, k) => {
+      const v2 = resolveBinding(v, bindings)
+      if (v2) {
+        params.set(k, v2)
+      }
+    })
+    u.search = "?" + params.toString()
+  }
+  return u
+}
+
+function resolveBinding(
+  value: string,
+  bindings: Bindings,
+  encoder: ((v: string) => string) | undefined = undefined,
+): string | undefined {
+  const first = value[0]
+  if (first === ":" || first === "?") {
+    const k = value.slice(1)
+    let v = bindings[k]
+    if (v === undefined) {
+      if (first === "?") {
+        return undefined
+      } else {
+        throw new Error(`Missing binding '${k}'.`)
+      }
+    }
+    if (typeof v !== "string") {
+      v = `${v}`
+    }
+    return encoder ? encoder(v) : v
+  } else {
+    return value
+  }
+}
+
+function _fetch(url: URL, request: RequestInit): Promise<HttpResponse> {
+  return fetch(url, request)
+    .then(parseResponse)
+    .then(([content, contentType, mimeType, response]) => {
+      return {
+        statusCode: response.status,
+        content,
+        contentType,
+        mimeType,
+        size: getSize(response),
+        headers: response.headers,
+      }
+    })
+}
+
+function getSize(response: Response): number {
+  const s = response.headers.get("Content-Length")
+  if (!s) {
+    return -1
+  }
+  return Number(s)
+}

package/src/router.ts

@@ -0,0 +1,171 @@
+import { Update, createBrowserHistory, Location } from 'history';
+import { getLogger } from './logger';
+import { registerActions } from './redux';
+import { DispatchF, PathQuery, PiReducer, ReduceF, ReduxAction, ReduxState, Route } from './types';
+import { PiRegister } from '.';
+
+const logger = getLogger("router")
+export const browserHistory = createBrowserHistory();
+
+// type Route = {
+//   path: string[]
+//   query: PathQuery
+//   url: string
+//   fromBrowser?: boolean
+// }
+
+export const ACTION_TYPES = registerActions('pi/router', ['show_page', 'navigate_to_page']);
+
+export type ShowPageEvent = {
+  path: string[]
+  query?: PathQuery
+  fromBrowser?: boolean
+}
+export const onShowPage = createOnAction<ShowPageEvent>(ACTION_TYPES.SHOW_PAGE)
+
+export const showPage = (dispatch: DispatchF, path: string[], query?: PathQuery) => {
+  dispatch(createShowPageAction(path, query))
+}
+
+export const createShowPageAction = (path: string[], query?: PathQuery): ReduxAction & ShowPageEvent => ({
+  type: ACTION_TYPES.SHOW_PAGE,
+  path, query, fromBrowser: false
+})
+
+export type NavigateToPageEvent = {
+  url: string
+  fromBrowser: boolean
+}
+export const onNavigateToPage = createOnAction<NavigateToPageEvent>(ACTION_TYPES.NAVIGATE_TO_PAGE)
+
+export const ON_INIT_ACTION = "pi/start"
+export const onInit = createOnAction<{}>(ON_INIT_ACTION)
+
+export function currentRoute(pathPrefix = ''): Route {
+  const f = route_functions(pathPrefix)
+  const r2 = f.url2route(window.location.href)
+  const r = f.location2route(browserHistory.location)
+  return r
+
+}
+
+export function init(reducer: PiReducer, pathPrefix = ''): Route {
+  let workingURL: string
+  const f = route_functions(pathPrefix)
+
+  browserHistory.listen(({ action, location }: Update) => {
+    // location is an object like window.location
+    const { url } = f.location2route(location)
+    if (workingURL !== url) {
+      logger.info('browser history:', url, action)
+      setTimeout(() => navigateToPage(url, action === 'POP'))
+    }
+  });
+
+  function browserPath(): Route {
+    return f.location2route(browserHistory.location)
+  }
+
+  function navigateToPage(url: string, fromBrowser = false) {
+    reducer.dispatch({
+      type: ACTION_TYPES.NAVIGATE_TO_PAGE,
+      url,
+      fromBrowser,
+    });
+  }
+
+  reducer.register<ReduxState, ReduxAction & NavigateToPageEvent>(
+    ACTION_TYPES.NAVIGATE_TO_PAGE,
+    (state, { url, fromBrowser }, dispatch) => {
+      const r = f.url2route(url)
+      r.fromBrowser = fromBrowser
+      if (workingURL && state.route?.url === r.url) {
+        return state;
+      }
+      dispatch({
+        type: ACTION_TYPES.SHOW_PAGE,
+        ...r,
+      });
+      return state
+    });
+
+  reducer.register<ReduxState, ReduxAction & ShowPageEvent>(
+    ACTION_TYPES.SHOW_PAGE,
+    (state, { path, query = {}, fromBrowser = false }) => {
+      const route = f.pathl2route(path, query)
+      workingURL = route.url
+      if (!fromBrowser) {
+        const hp = browserPath()
+        if (route.url !== hp.url) {
+          browserHistory.push(route.url);
+        }
+      }
+      state.route = {
+        ...route,
+        fromBrowser,
+      }
+      return state
+    });
+
+  reducer.register('@@INIT', (state) => {
+    const url = browserPath().url
+    logger.info(`Request navigation to '${url}'`);
+    setTimeout(() => navigateToPage(url, true));
+    return state;
+  });
+  return f.location2route(browserHistory.location)
+};
+
+function route_functions(pathPrefix = '') {
+  const location2route = (location: Location): Route => {
+    const [p, s] = [location.pathname, location.search]
+    const url = s ? `${p}${s}` : p
+    return url2route(url)
+  }
+
+  const url2route = (url: string): Route => {
+    const [pn, search] = url.split("?")
+
+    const path = pn.substring(pathPrefix.length).split('/').filter(s => s !== '');
+    const query = {} as PathQuery
+    const s = search
+    if (s && s.length > 0) {
+      s.split('&').forEach((el) => {
+        const [k, v] = el.split('=');
+        query[decodeURI(k)] = v ? decodeURI(v) : true;
+      });
+    }
+    return { url, path, query }
+  }
+
+  const pathl2route = (path: string[], query: PathQuery): Route => {
+    let url = `${pathPrefix}/${path.join('/')}`
+    if (query) {
+      const qa = Object.entries(query);
+      if (qa.length > 0) {
+        const s = qa.map(([k, v]) => {
+          const n = encodeURI(k)
+          if (typeof v === 'boolean') {
+            return n
+          } else if (typeof v === 'number') {
+            return `${n}=${v}`
+          } else {
+            return `${n}=${encodeURI(v)}`
+          }
+        }).join('&')
+        url = `${url}?${s}`
+      }
+    }
+    return { url, path, query }
+  }
+  return { location2route, url2route, pathl2route }
+}
+
+function createOnAction<E>(actionType: string): <S extends ReduxState>(
+  register: PiRegister,
+  f: ReduceF<S, ReduxAction & E>,
+) => void {
+  return (register, f) => {
+    register.reducer.register(actionType, f)
+  }
+}

package/src/store.ts

@@ -0,0 +1,19 @@
+// import { configureStore, ThunkAction, Action } from "@reduxjs/toolkit"
+// import counterReducer from "../UNUSED/features/counter/counterSlice"
+
+// export type Store = any
+
+// export const store: Store = configureStore({
+//   reducer: {
+//     counter: counterReducer,
+//   },
+// })
+
+// export type AppDispatch = typeof store.dispatch
+// export type RootState = ReturnType<typeof store.getState>
+// export type AppThunk<ReturnType = void> = ThunkAction<
+//   ReturnType,
+//   RootState,
+//   unknown,
+//   Action<string>
+// >