@stack-spot/portal-network 0.1.0

package/src/network/AutoQuery.ts

@@ -0,0 +1,80 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+
+import { DefinedUseQueryResult, UseQueryOptions, UseSuspenseQueryResult, useQuery, useSuspenseQuery } from '@tanstack/react-query'
+import { StackspotAPIError } from '../error/StackspotAPIError'
+import { AutoOperation } from './AutoOperation'
+import { queryClient } from './react-query-client'
+import { AutoQueryObjectParams, QueryObject } from './types'
+
+export class AutoQuery<Variables, Result> extends AutoOperation<Variables> implements QueryObject<Variables, Result> {
+  /**
+   * Prevents the same request from being triggered more than once if subsequent calls are made before the first ends.
+   */
+  private currentRequests = new Map<Variables | undefined, Promise<Result>>()
+  constructor(params: AutoQueryObjectParams<Variables, Result>) {
+    super(params)
+  }
+
+  private createQueryFn(variables: Variables | undefined) {
+    return async () => {
+      if (!this.currentRequests.has(variables)) this.currentRequests.set(variables, this.callFn(variables))
+      const result = await this.currentRequests.get(variables)
+      this.currentRequests.delete(variables)
+      return result!
+    }
+  }
+
+  query(...[variables]: Variables extends void ? [] : [variables: Variables]) {
+    return queryClient.fetchQuery({
+      queryKey: this.getKey(variables),
+      queryFn: this.createQueryFn(variables),
+    })
+  }
+
+  #useQueryResult<T extends boolean>(
+    suspense: T,
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables: Variables, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) {
+    /* `this.fn` is a oazapfts function, i.e. it has arity 1 or 2. If it accepts variables, its arity is 2: the 1st parameter is the
+    variables and the 2nd is the RequestOpts. If it doesn't accept variables, its arity is one: it accepts only the RequestOpts.
+    We can use this information to determine what the type of `args` actually is at runtime. If variables are accepted, than the 1st
+    argument is the variables and the 2nd is the query options, otherwise, it has a single argument, which is the query options. */
+    const [variables, options] = this.fn.length > 1
+      ? args as [Variables, Omit<UseQueryOptions, 'queryFn' | 'queryKey'> | undefined]
+      : [undefined, args[0] as Omit<UseQueryOptions, 'queryFn' | 'queryKey'> | undefined]
+    const use = suspense ? useSuspenseQuery : useQuery
+    return use({
+      ...options,
+      queryKey: this.getKey(variables),
+      queryFn: this.createQueryFn(variables),
+    }, queryClient) as T extends true ? UseSuspenseQueryResult<Result, StackspotAPIError> : DefinedUseQueryResult<Result, StackspotAPIError>
+  }
+
+  useQuery(
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables: Variables, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) {
+    const result = this.#useQueryResult(true, ...args)
+    return result.data
+  }
+
+  useStatefulQuery(
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables: Variables, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) {
+    const result = this.#useQueryResult(false, ...args)
+    return [result.data, result.isPending, result.error as StackspotAPIError | undefined, result] as const
+  }
+
+  invalidate(variables?: Partial<Variables>) {
+    return queryClient.invalidateQueries({ queryKey: this.getKey(variables) })
+  }
+
+  getKey(variables?: Partial<Variables>)  {
+    return [this.apiName, this.fn.name, variables]
+  }
+}

package/src/network/ManualMutation.ts

@@ -0,0 +1,41 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+
+import { UseMutationOptions, useMutation } from '@tanstack/react-query'
+import { StackspotAPIError } from '../error/StackspotAPIError'
+import { ManualOperation } from './ManualOperation'
+import { queryClient } from './react-query-client'
+import { FullOperationConfig, MutationObject } from './types'
+
+export class ManualMutation<
+  Variables extends Record<string, any> | void,
+  Result
+> extends ManualOperation<Variables> implements MutationObject<Variables, Result> {
+  constructor(config: FullOperationConfig<Variables extends void ? [AbortSignal] : [AbortSignal, Variables], Result>) {
+    super(config)
+  }
+
+  private async makeRequest(variables?: Record<string, any>) {
+    const abortController = new AbortController()
+    if (!this.abortMap.has(variables)) this.abortMap.set(variables, [])
+    this.abortMap.get(variables)?.push(abortController)
+    try {
+      return await this.config.request(
+        ...[abortController.signal, variables] as Variables extends void ? [AbortSignal] : [AbortSignal, Variables],
+      )
+    } finally {
+      this.abortMap.delete(variables)
+    }
+  }
+
+  mutate(...args: Variables extends void ? [] : [variables: Variables]) {
+    return this.makeRequest(...args)
+  }
+
+  useMutation(options?: Omit<UseMutationOptions<Result, StackspotAPIError, Variables>, 'mutationFn'>) {
+    const result = useMutation<Result, StackspotAPIError, Variables>({
+      ...options,
+      mutationFn: (...args: any) => this.makeRequest(...args),
+    }, queryClient)
+    return [result.mutateAsync as any, result.isPending, result.error as StackspotAPIError | undefined, result as any] as const
+  }
+}

package/src/network/ManualOperation.ts

@@ -0,0 +1,55 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+
+import { UseQueryOptions, UseQueryResult, useQuery } from '@tanstack/react-query'
+import { CanceledError } from '../error/CanceledError'
+import { StackspotAPIError } from '../error/StackspotAPIError'
+import { queryClient } from './react-query-client'
+import { FullOperationConfig, OperationObject } from './types'
+
+export abstract class ManualOperation<Variables extends Record<string, any> | void> implements OperationObject<Variables> {
+  protected config: FullOperationConfig<Variables extends void ? [AbortSignal] : [AbortSignal, Variables], any>
+  protected abortMap = new Map<Record<string, any> | undefined, AbortController[]>()
+
+  constructor(config: FullOperationConfig<Variables extends void ? [AbortSignal] : [AbortSignal, Variables], any>) {
+    this.config = config
+  }
+
+  isAllowed(...[variables]: Variables extends void ? [] : [variables?: Partial<Variables>]) {
+    return queryClient.fetchQuery({
+      queryKey: this.getPermissionKey(variables as Variables),
+      // @ts-ignore the following is correct. TS can't correctly infer the conditional type here =(
+      queryFn: () => this.config.permission(variables),
+    })
+  }
+
+  useAllowed(
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables?: Partial<Variables>, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) {
+    const [variables, options] = args.length === 2 ? args : [undefined, args[0]]
+    const result = useQuery({
+      ...options,
+      queryKey: this.getPermissionKey(variables as Variables),
+      // @ts-ignore the following is correct. TS can't correctly infer the conditional type here =(
+      queryFn: () => this.config.permission(variables),
+    }, queryClient) as UseQueryResult<boolean, StackspotAPIError>
+    return [result.data, result.isPending, result.error, result] as const
+  }
+
+  getPermissionKey(variables?: Partial<Variables>) {
+    return [this.config.apiName, `${this.config.name}.permission`, variables]
+  }
+
+  cancel(variables?: Partial<Variables> | undefined) {
+    if (variables && this.abortMap.has(variables)) {
+      this.abortMap.get(variables)?.forEach(c => c.abort(new CanceledError()))
+      return true
+    }
+    if (!variables && this.abortMap.size) {
+      this.abortMap.forEach(controllers => controllers.forEach(c => c.abort(new CanceledError())))
+      return true
+    }
+    return false
+  }
+}

package/src/network/ManualQuery.ts

@@ -0,0 +1,93 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+
+import { DefinedUseQueryResult, UseQueryOptions, UseSuspenseQueryResult, useQuery, useSuspenseQuery } from '@tanstack/react-query'
+import { StackspotAPIError } from '../error/StackspotAPIError'
+import { ManualOperation } from './ManualOperation'
+import { queryClient } from './react-query-client'
+import { FullOperationConfig, QueryObject } from './types'
+
+export class ManualQuery<
+  Variables extends Record<string, any> | void,
+  Result
+> extends ManualOperation<Variables> implements QueryObject<Variables, Result> {
+  /**
+   * Prevents the same request from being triggered more than once if subsequent calls are made before the first ends.
+   */
+  private currentRequests = new Map<Record<string, any> | undefined, Promise<Result>>()
+
+  constructor(config: FullOperationConfig<Variables extends void ? [AbortSignal] : [AbortSignal, Variables], Result>) {
+    super(config)
+  }
+
+  private async makeRequest(variables: Record<string, any> | undefined) {
+    const abortController = new AbortController()
+    this.abortMap.set(variables, [abortController])
+    try {
+      return await this.config.request(
+        ...[abortController.signal, variables] as Variables extends void ? [AbortSignal] : [AbortSignal, Variables],
+      )
+    } finally {
+      this.abortMap.delete(variables)
+      this.currentRequests.delete(variables)
+    }
+  }
+
+  private createQueryFn(variables: Record<string, any> | undefined) {
+    return () => {
+      if (!this.currentRequests.has(variables)) this.currentRequests.set(variables, this.makeRequest(variables))
+      return this.currentRequests.get(variables)!
+    }
+  }
+
+  query(...[variables]: Variables extends void ? [] : [variables: Variables]) {
+    return queryClient.fetchQuery({
+      queryKey: this.getKey(variables as Variables),
+      queryFn: this.createQueryFn(variables),
+    })
+  }
+
+  #useQueryResult<T extends boolean>(
+    suspense: T,
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables: Variables, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) {
+    /* `this.config.request` is a function with arity 1 or 2. If it accepts variables, its arity is 2: the 1st parameter is the
+    AbortSignal and the 2nd is the variables. If it doesn't accept variables, its arity is one: it accepts only the AbortSignal.
+    We can use this information to determine what the type of `args` actually is at runtime. If variables are accepted, than the 1st
+    argument is the variables and the 2nd is the query options, otherwise, it has a single argument, which is the query options. */
+    const [variables, options] = this.config.request.length === 2 ? args : [undefined, args[0]]
+    const use = suspense ? useSuspenseQuery : useQuery
+    return use({
+      ...options,
+      queryKey: this.getKey(variables as Variables),
+      queryFn: this.createQueryFn(variables),
+    }, queryClient) as T extends true ? UseSuspenseQueryResult<Result, StackspotAPIError> : DefinedUseQueryResult<Result, StackspotAPIError>
+  }
+
+  useQuery(
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables: Variables, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) {
+    const result = this.#useQueryResult(false, ...args)
+    return result.data
+  }
+
+  useStatefulQuery(
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables: Variables, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) {
+    const result = this.#useQueryResult(false, ...args)
+    return [result.data, result.isPending, result.error as StackspotAPIError | undefined, result] as const
+  }
+
+  invalidate(variables?: Partial<Variables>) {
+    return queryClient.invalidateQueries({ queryKey: this.getKey(variables) })
+  }
+
+  getKey(variables?: Partial<Variables>)  {
+    return [this.config.apiName, this.config.name, variables]
+  }
+}

package/src/network/NetworkClient.ts

@@ -0,0 +1,93 @@
+import { mergeHeaders } from '@oazapfts/runtime/headers'
+import { AuthenticationError } from '@stack-spot/auth'
+import { requestPermission } from '@stack-spot/opa'
+import { Env, HTTPMethod, RequestOptions, RequestWithBody, SessionManager } from './types'
+
+export class NetworkClient {
+  private baseURL: Record<Env, string>
+  private static sessionManager?: SessionManager
+  private static env?: Env
+
+  constructor(baseURL: Record<Env, string>) {
+    this.baseURL = baseURL
+  }
+
+  static setup(sessionManager: SessionManager, env: Env) {
+    NetworkClient.sessionManager = sessionManager
+    NetworkClient.env = env
+  }
+
+  private uninitializedError() {
+    return new Error('Please, call "NetworkClient.setup(sessionManager, env)" before attempting to make a request.')
+  }
+
+  protected resolveURL(path: string) {
+    if (!NetworkClient.env) throw this.uninitializedError()
+    // paths must not start with "/", otherwise, the base url will not be fully appended to it.
+    const fixedPath = path.replace(/^\//, '')
+    // the baseUrl must end with "/", otherwise, the last of its part will get replaced by the path, instead of concatenated with.
+    const fixedBaseUrl = this.baseURL[NetworkClient.env].replace(/([^/])$/, '$1/')
+    return new URL(fixedPath, fixedBaseUrl)
+  }
+
+  protected requestPermission(method: HTTPMethod, path: string, body?: string | object): Promise<boolean> {
+    return requestPermission(method, this.resolveURL(path).toString(), body)
+  }
+
+  private getSessionManager() {
+    const sessionManager = NetworkClient.sessionManager
+    if (!sessionManager) throw this.uninitializedError()
+    return sessionManager
+  }
+
+  private sendRequest(path: string, method: HTTPMethod, request?: RequestWithBody): Promise<Response> {
+    const sessionManager = this.getSessionManager()
+    const url = this.resolveURL(path)
+    try {
+      if (request?.params) {
+        Object.keys(request.params).forEach((key) => {
+          const value = request?.params?.[key]
+          if (value !== undefined) url.searchParams.set(key, value)
+        })
+      }
+      const isFormData = request?.body instanceof FormData
+      const isJsonContent = (typeof request?.body === 'object') && !isFormData
+      const body = isJsonContent ? JSON.stringify(request.body) : request?.body as string | FormData
+      const defaultHeaders: Record<string, string> = isJsonContent ? { 'Content-Type': 'application/json' } : {}
+      const headers = mergeHeaders(defaultHeaders, request?.headers)
+      return (
+        sessionManager.hasSession()
+          ? sessionManager.getSession().fetch(url, { method: method.toUpperCase(), headers, body })
+          : fetch(url, { method: method.toUpperCase(), headers, body })
+      )
+    } catch (error) {
+      if (error instanceof AuthenticationError) sessionManager.endSession()
+      throw error
+    }
+  }
+
+  protected get<T>(path: string, request?: RequestOptions): Promise<T> {
+    return this.sendRequest(path, 'get', request) as Promise<T>
+  }
+
+  protected post<T>(path: string, request?: RequestWithBody): Promise<T> {
+    return this.sendRequest(path, 'post', request) as Promise<T>
+  }
+
+  protected put<T>(path: string, request?: RequestWithBody): Promise<T> {
+    return this.sendRequest(path, 'put', request) as Promise<T>
+  }
+
+  protected patch<T>(path: string, request?: RequestWithBody): Promise<T> {
+    return this.sendRequest(path, 'patch', request) as Promise<T>
+  }
+
+  protected delete<T>(path: string, request?: RequestWithBody): Promise<T> {
+    return this.sendRequest(path, 'delete', request) as Promise<T>
+  }
+
+  protected isFreemium() {
+    const sessionManager = this.getSessionManager()
+    return sessionManager.hasSession() && !!sessionManager.getSession().getTokenData().freemium_status
+  }
+}

package/src/network/ReactQueryNetworkClient.ts

@@ -0,0 +1,154 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+
+import { Defaults, HttpError, RequestOpts } from '@oazapfts/runtime'
+import { StackspotAPIError } from '../error/StackspotAPIError'
+import { AutoMutation } from './AutoMutation'
+import { AutoQuery } from './AutoQuery'
+import { ManualMutation } from './ManualMutation'
+import { ManualQuery } from './ManualQuery'
+import { NetworkClient } from './NetworkClient'
+import { Env, HTTPMethod, MutationObject, OperationConfig, OperationObject, QueryObject } from './types'
+
+const DUMMY_ULID = '01HSTZ5471CBG4AW9BFJ0VTVG9'
+const PERMISSION_ERROR = 'permission-error'
+
+export abstract class ReactQueryNetworkClient extends NetworkClient {
+  constructor(baseURL: Record<Env, string>, defaults: Defaults<any>) {
+    super(baseURL)
+    defaults.baseUrl = ''
+    // eslint-disable-next-line arrow-body-style
+    defaults.fetch = (...args) => {
+      return this.#onFetch(...args)
+    }
+  }
+
+  #getMappedHeaders(headers: HeadersInit | undefined) {
+    if (!headers) return undefined
+    if (headers instanceof Headers) {
+      const headersMap: Record<string, string> = {}
+      headers.forEach((value, key) => headersMap[key] = value)
+      return headersMap
+    }
+    if (Array.isArray(headers)) {
+      const headersMap: Record<string, string> = {}
+      headers.forEach(([key, value]) => headersMap[key] = value)
+      return headersMap
+    }
+    return headers
+  }
+
+  #parseErrorData(error: HttpError) {
+    if (typeof error.data === 'string') {
+      try {
+        return JSON.parse(error.data)
+      } catch { /* empty */ }
+    }
+    return error.data
+  }
+
+  #transformError(error: any): StackspotAPIError {
+    if (!(error instanceof HttpError)) throw new StackspotAPIError({ status: 0, message: error?.message || `${error}`, stack: error.stack })
+    const data = this.#parseErrorData(error)
+    if (data.type === PERMISSION_ERROR) {
+      // eslint-disable-next-line no-console
+      console.error('Error while validating permissions:', data.message)
+      return new StackspotAPIError({
+        status: 500,
+        stack: error.stack,
+        message: language => language === 'pt'
+          ? 'Ocorreu um erro ao validar as permissões.'
+          : 'There was an error while validating permissions.',
+      })
+    }
+    return this.buildStackSpotError(error)
+  }
+
+  #withErrorTreatment = <Args extends any[], Result>(block: (...args: Args) => Promise<Result>): ((...args: Args) => Promise<Result>) => (
+    async (...args) => {
+      try {
+        return await block(...args)
+      } catch (error: any) {
+        throw this.#transformError(error)
+      }
+    }
+  )
+
+  #onFetch(input: string | URL | Request, init?: RequestInit | undefined): Promise<Response> {
+    const [path, method, body, headers] = input instanceof Request
+      ? [input.url, input.method as HTTPMethod, input.body, input.headers]
+      : [`${input}`, (init?.method?.toLowerCase() || 'get') as HTTPMethod, init?.body, init?.headers]
+    return this[method](path, { body: body as any, headers: this.#getMappedHeaders(headers) })
+  }
+
+  protected abstract buildStackSpotError(error: HttpError): StackspotAPIError
+
+  async #onFetchPermission(input: string | URL | Request, init?: RequestInit | undefined): Promise<Response> {
+    const [path, method, body] = input instanceof Request
+      ? [input.url, input.method as HTTPMethod, input.body]
+      : [`${input}`, (init?.method?.toLowerCase() || 'get') as HTTPMethod, init?.body]
+    try {
+      /* We allow the dev not to pass any variable when validating a permission. For this reason, oazapfts might generate a path with
+      "undefined". If this happens, we must replace the undefined text with a dummy ULID. */
+      const fixedPath = path.replace(/\/undefined(\/|$)/g, `/${DUMMY_ULID}$1`)
+      const isAllowed = await this.requestPermission(method, fixedPath, body as any)
+      return new Response(`${isAllowed}`, { headers: { 'Content-Type': 'application/json' } })
+    } catch (error: any) {
+      return new Response(JSON.stringify({ type: PERMISSION_ERROR, message: error.message || `${error}` }), { status: 500 })
+    }
+  }
+
+  protected query<Args extends [opts?: RequestOpts] | [variables: Record<string, any>, opts?: RequestOpts], Result>(
+    fn: (...args: Args) => Promise<Result>
+  ): Args extends [variables: infer Variables, opts?: RequestOpts] ? QueryObject<Variables, Result> : QueryObject<void, Result>
+  protected query<Args extends [AbortSignal, Record<string, any>] | [AbortSignal], Result>(
+    config: OperationConfig<Args, Result>,
+  ): QueryObject<Args extends [AbortSignal] ? void : Args[1], Result>
+  protected query<Args extends [AbortSignal, Record<string, any>] | [AbortSignal], Result>(
+    config: Omit<OperationConfig<Args, Result>, 'permission'>,
+  ): Omit<QueryObject<Args extends [AbortSignal] ? void : Args[1], Result>, 'isAllowed' | 'useAllowed' | 'getPermissionKey'>
+  protected query(fnOrConfig: any): QueryObject<any, any> {
+    return typeof fnOrConfig === 'function'
+      ? new AutoQuery(
+        {
+          apiName: this.constructor.name,
+          fn: fnOrConfig,
+          onFetchPermission: (...args) => this.#onFetchPermission(...args),
+          transformError: error => this.#transformError(error),
+        },
+      )
+      : new ManualQuery({
+        ...fnOrConfig,
+        apiName: this.constructor.name,
+        request: this.#withErrorTreatment(fnOrConfig.request),
+        permission: fnOrConfig.permission ? this.#withErrorTreatment(fnOrConfig.permission) : undefined,
+      })
+  }
+
+  protected mutation<Args extends [opts?: RequestOpts] | [variables: Record<string, any>, opts?: RequestOpts], Result>(
+    fn: (...args: Args) => Promise<Result>,
+  ): Args extends [variables: infer Variables, opts?: RequestOpts] ? MutationObject<Variables, Result> : MutationObject<void, Result>
+  protected mutation<Args extends [AbortSignal, Record<string, any>] | [AbortSignal], Result>(
+    config: OperationConfig<Args, Result>,
+  ): MutationObject<Args extends [AbortSignal] ? void : Args[1], Result>
+  protected mutation<Args extends [AbortSignal, Record<string, any>] | [AbortSignal], Result>(
+    config: Omit<OperationConfig<Args, Result>, 'permission'>,
+  ): Omit<MutationObject<Args extends [AbortSignal] ? void : Args[1], Result>, keyof OperationObject<any>>
+  protected mutation(fnOrConfig: any): MutationObject<any, any> {
+    if (typeof fnOrConfig === 'function') {
+      return new AutoMutation(
+        {
+          apiName: this.constructor.name,
+          fn: fnOrConfig,
+          onFetchPermission: (...args) => this.#onFetchPermission(...args),
+          transformError: error => this.#transformError(error),
+        },
+      )
+    }
+    return new ManualMutation({
+      ...fnOrConfig,
+      apiName: this.constructor.name,
+      request: this.#withErrorTreatment(fnOrConfig.request),
+      permission: fnOrConfig.permission ? this.#withErrorTreatment(fnOrConfig.permission) : undefined,
+    })
+  }
+}

package/src/network/react-query-client.ts

@@ -0,0 +1,3 @@
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({ defaultOptions: { queries: { refetchOnWindowFocus: false, retry: 3 } } })

package/src/network/types.ts

@@ -0,0 +1,82 @@
+import type { RequestOpts } from '@oazapfts/runtime'
+import { Session } from '@stack-spot/auth'
+import { MutateOptions, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query'
+import { StackspotAPIError } from '../error/StackspotAPIError'
+
+export interface SessionManager {
+  hasSession(): boolean,
+  endSession(): void,
+  getSession(): Session,
+}
+
+export interface RequestOptions {
+  params?: Record<string, string | undefined>,
+  headers?: Record<string, string>,
+}
+
+export interface RequestWithBody extends RequestOptions {
+  body?: string | object | FormData,
+}
+
+export type Env = 'dev' | 'stg' | 'prd'
+
+export type HTTPMethod = 'post' | 'patch' | 'delete' | 'put' | 'get'
+
+export interface OperationConfig<Args extends [AbortSignal, Record<string, any>] | [AbortSignal], Result> {
+  name: string,
+  request: (...args: Args) => Promise<Result>,
+  permission: (...args: Args extends [AbortSignal] ? [] : [Args[1]]) => Promise<boolean>,
+}
+
+export interface FullOperationConfig<
+  Args extends [AbortSignal, Record<string, any>] | [AbortSignal], Result
+> extends OperationConfig<Args, Result>  {
+  apiName: string,
+}
+
+export interface OperationObject<Variables> {
+  isAllowed: (...args: Variables extends void ? [] : [variables?: Partial<Variables>]) => Promise<boolean>,
+  useAllowed: (
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables?: Partial<Variables>, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) => Readonly<[boolean | undefined, boolean, StackspotAPIError | null | undefined, UseQueryResult<boolean, StackspotAPIError>]>,
+  getPermissionKey: (...args: Variables extends void ? [] : [variables?: Partial<Variables>]) => any[],
+  cancel: (variables?: Partial<Variables>) => boolean,
+}
+
+export interface QueryObject<Variables, Result> extends OperationObject<Variables> {
+  query: (...args: Variables extends void ? [] : [variables: Variables]) => Promise<Result>,
+  useQuery: (
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables: Variables, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) => Result | undefined,
+  useStatefulQuery: (
+    ...args: Variables extends void
+      ? [options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+      : [variables: Variables, options?: Omit<UseQueryOptions, 'queryFn' | 'queryKey'>]
+  ) => Readonly<[Result | undefined, boolean, StackspotAPIError | null | undefined, UseQueryResult<Result, StackspotAPIError>]>,
+  invalidate: (...args: Variables extends void ? [] : [variables?: Partial<Variables>]) => Promise<void>,
+  getKey: (...args: Variables extends void ? [] : [variables?: Partial<Variables>]) => any[],
+}
+
+export interface AutoQueryObjectParams<Variables, Result> {
+  apiName: string,
+  fn: ((variables: Variables, opts?: RequestOpts) => Promise<Result>) | ((opts?: RequestOpts) => Promise<Result>),
+  onFetchPermission: typeof fetch,
+  transformError?: (error: any) => StackspotAPIError,
+}
+
+export interface MutationObject<Variables, Result> extends OperationObject<Variables> {
+  mutate: (...args: Variables extends void ? [] : [variables: Variables]) => Promise<Result>,
+  useMutation: (options?: Omit<UseMutationOptions<Result, StackspotAPIError, Variables>, 'mutationFn'>) =>
+    Readonly<[
+      (...args: Variables extends void
+        ? [options?:  MutateOptions<Result, StackspotAPIError>]
+        : [variables: Variables, options?: MutateOptions<Result, StackspotAPIError, Variables>]
+      ) => Promise<Result>,
+      boolean, StackspotAPIError | undefined,
+      UseMutationResult<Result, StackspotAPIError, Variables>,
+    ]>,
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig",
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig",
+  "compilerOptions": {
+    "module": "ESNext",
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "stripInternal": true,
+  },
+  "include": ["src", "scripts"]
+}