foobara-typescript-remote-command-generator 0.0.20 → 0.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4528c916d3984695d98001864a1ab16ee6b71413d4602b86fa98691197462603
-  data.tar.gz: 15e85d4edb9cafde3c3bbf198f6e1a8a9801ba7123228eb18320eb74d291c23b
+  metadata.gz: 894c3cb3bb470bc2ae517516af5eadf72271a842d91b4d9d3091df927a59f7ef
+  data.tar.gz: d78ee07ebf763f5c81459f5eb20c27e30b7f99f36975258e938fef80fb8f2e82
 SHA512:
-  metadata.gz: 47432f9b6da3f579bf74a94201e3bef097c0bfe928fafd3d334a9e9f9e7aa0465a7b65e827ae44d9a42d01391caee0637bd5d6ad6e5e9e2c80f9c21623561bf4
-  data.tar.gz: c2510181c61cc4bd7b6126d95b8edebb33ef5c27f50ee9ce76a76da5a64ecc9894dd0226122503f4d33099a2d50c7ea64e5727f6609a40a21b5368af34108628
+  metadata.gz: '058e5c94c619269433b72e3ef51caf0eebbe808420334af00482d234bdfc153ab3dc40946c023e6cd65a77f1ee3e56bf2323b256981990403ad928d1ec9bfb25'
+  data.tar.gz: 4b83e9a472967eed6c6aea176f0b966374aa1f688d17a5c6c7a46f45849a499f34dcb3489a24173f7b7d11a35c5f348763158afa34abb2391df7265e79de1847

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [0.0.21] - 2025-05-13
+
+- Implement Query/QueryCache/useQuery to use commands as data sources and share that data across components
+
 ## [0.0.20] - 2025-05-03
 
 - Add a potentially missing require_relative

data/src/remote_generator/services/auth/setup_generator.rb

@@ -0,0 +1,19 @@
+module Foobara
+  module RemoteGenerator
+    class Services
+      module Auth
+        class SetupGenerator < TypescriptFromManifestBaseGenerator
+          def applicable?
+            relevant_manifest.commands.any? do |command_manifest|
+              command_manifest.full_command_name =~ /\bGetCurrentUser$/
+            end
+          end
+
+          def template_path
+            "setup.ts.erb"
+          end
+        end
+      end
+    end
+  end
+end

data/src/remote_generator/services/typescript_from_manifest_base_generator.rb

@@ -80,7 +80,10 @@ module Foobara
             when Manifest::ProcessorClass
               Services::ProcessorClassGenerator
             when Manifest::RootManifest
-              Services::RootManifestGenerator
+              [
+                Services::RootManifestGenerator,
+                Services::Auth::SetupGenerator
+              ]
             when Manifest::Type
               Services::TypeGenerator
             else

data/src/remote_generator/write_typescript_to_disk.rb

@@ -59,6 +59,7 @@ module Foobara
 
       def run_post_generation_tasks
         eslint_fix
+        warn_about_adding_setup_to_index
       end
 
       def eslint_fix
@@ -73,6 +74,13 @@ module Foobara
           end
         end
       end
+
+      def warn_about_adding_setup_to_index
+        if paths_to_source_code.key?("setup.ts")
+          warn "WARNING: you should add the following to src/index.ts:\n\n" \
+               "import './domains/setup'"
+        end
+      end
     end
   end
 end

data/templates/Foobara/Auth/utils/accessTokens.ts.erb

@@ -1,11 +1,31 @@
+import type Query from '../../../base/Query'
+import type RemoteCommand from '../../../base/RemoteCommand'
+
+let getCurrentUserQuery: Query<RemoteCommand<any, any, any>> | undefined
+
+export function setGetCurrentUserQuery (query: Query<RemoteCommand<any, any, any>>): void {
+  getCurrentUserQuery = query
+}
+
+function setCurrentUserDirty () {
+  console.log('setCurrentUserDirty')
+  if (getCurrentUserQuery != null) {
+    getCurrentUserQuery.setDirty()
+  }
+}
+
 const accessTokens = new Map<string, string>()
 
-const logout = (urlBase: string): void => { accessTokens.delete(urlBase) }
+const logout = (urlBase: string): void => {
+  accessTokens.delete(urlBase)
+  setCurrentUserDirty()
+}
 let handleLogout: (baseUrl: string) => void = logout
 
 const tokenForUrl = (baseUrl: string): string | undefined => accessTokens.get(baseUrl)
 const handleLogin: (baseUrl: string, accessToken: string) => void = (baseUrl, accessToken) => {
   accessTokens.set(baseUrl, accessToken)
+  setCurrentUserDirty()
 }
 
 if (typeof BroadcastChannel !== 'undefined') {

data/templates/base/Query.ts

@@ -0,0 +1,125 @@
+import type RemoteCommand from '../base/RemoteCommand'
+import { type Outcome } from '../base/Outcome'
+import {
+  type InputsOf, type ResultOf, type ErrorOf, type RemoteCommandConstructor
+} from './RemoteCommandTypes'
+
+export default class Query<CommandT extends RemoteCommand<any, any, any>> {
+  inputs: InputsOf<CommandT>
+  CommandClass: RemoteCommandConstructor<CommandT>
+  command: CommandT | undefined
+  isLoading: boolean = false
+  isFailure: boolean = false
+  isDirty: boolean = false
+  ranWhileRunning: boolean = false
+  listeners: Array<() => void> = []
+  inputsChangedListeners: Array<() => void> = []
+  failure: any
+
+  constructor (
+    CommandClass: RemoteCommandConstructor<CommandT>,
+    inputs: InputsOf<CommandT> | undefined = undefined
+  ) {
+    this.CommandClass = CommandClass
+    this.inputs = inputs ?? (undefined as unknown as InputsOf<CommandT>)
+  }
+
+  get outcome (): null | Outcome<ResultOf<CommandT>, ErrorOf<CommandT>> {
+    return this.command?.outcome ?? null
+  }
+
+  get result (): null | ResultOf<CommandT> {
+    return this.command?.outcome?.result ?? null
+  }
+
+  get errors (): null | Array<ErrorOf<CommandT>> {
+    return this.command?.outcome?.errors ?? null
+  }
+
+  onChange (callback: () => void): () => void {
+    this.listeners.push(callback)
+    return () => {
+      const index = this.listeners.indexOf(callback)
+      if (index !== -1) {
+        this.listeners.splice(index, 1)
+      }
+    }
+  }
+
+  onInputsChange (callback: () => void): () => void {
+    this.inputsChangedListeners.push(callback)
+
+    return () => {
+      const index = this.inputsChangedListeners.indexOf(callback)
+      if (index !== -1) {
+        this.inputsChangedListeners.splice(index, 1)
+      }
+    }
+  }
+
+  fireChange (): void {
+    this.listeners.forEach(listener => { listener() })
+  }
+
+  fireInputsChanged (): void {
+    this.inputsChangedListeners.forEach(listener => { listener() })
+  }
+
+  setInputs (inputs: InputsOf<CommandT>): void {
+    this.inputs = inputs
+    this.fireInputsChanged()
+    this.setDirty()
+  }
+
+  setDirty (): void {
+    this.isDirty = true
+    this.run()
+  }
+
+  get isSuccess (): boolean {
+    return !this.isFailure && (this.command?.outcome?.isSuccess() ?? false)
+  }
+
+  get isError (): boolean {
+    if (this.command?.outcome == null) {
+      return false
+    }
+    return !this.command.outcome.isSuccess()
+  }
+
+  get isPending (): boolean {
+    return !this.isLoading || !this.isFailure || this.command == null
+  }
+
+  async run (): Promise<void> {
+    if (this.isLoading) {
+      this.ranWhileRunning = true
+      this.fireChange()
+      return
+    }
+
+    try {
+      this.isLoading = true
+      const command = new this.CommandClass(this.inputs)
+      this.fireChange()
+
+      await command.run()
+
+      this.isFailure = false
+      this.isDirty = false
+      this.command = command
+      this.failure = undefined
+    } catch (error) {
+      this.isFailure = true
+      this.failure = error
+      throw error
+    } finally {
+      this.isLoading = false
+      this.fireChange()
+      if (this.ranWhileRunning) {
+        this.ranWhileRunning = false
+        this.run()
+      }
+    }
+  }
+}

data/templates/base/QueryCache.ts

@@ -0,0 +1,47 @@
+import type RemoteCommand from '../base/RemoteCommand'
+import Query from '../base/Query'
+import { type InputsOf, type RemoteCommandConstructor } from '../base/RemoteCommandTypes'
+
+const queryCache = new Map<string, Query<RemoteCommand<any, any, any>>>()
+
+export function getQuery<CommandT extends RemoteCommand<any, any, any>> (
+  CommandClass: RemoteCommandConstructor<CommandT>,
+  inputs: InputsOf<CommandT> | undefined = undefined
+): Query<CommandT> {
+  const key: string = toKey(CommandClass, inputs)
+  const hit = queryCache.get(key)
+
+  if (hit != null) {
+    return (hit as unknown as Query<CommandT>)
+  }
+
+  let query: Query<CommandT>
+  if (arguments.length === 2) {
+    query = new Query<CommandT>(CommandClass, inputs)
+    query.run()
+  } else {
+    query = new Query<CommandT>(CommandClass)
+  }
+
+  query.onInputsChange(() => {
+    queryCache.delete(key)
+    const newKey = toKey(CommandClass, query.inputs)
+    queryCache.set(newKey, query)
+  })
+
+  queryCache.set(key, query)
+  return query
+}
+
+function toKey<CommandT extends RemoteCommand<any, any, any>> (
+  CommandClass: RemoteCommandConstructor<CommandT>,
+  inputs: InputsOf<CommandT> | undefined
+): string {
+  let key: string = CommandClass.fullCommandName
+
+  if (inputs != null) {
+    key += JSON.stringify(inputs)
+  }
+
+  return key
+}

data/templates/base/RemoteCommandTypes.ts

@@ -0,0 +1,10 @@
+import type RemoteCommand from './RemoteCommand'
+
+export type InputsOf<CommandClass> = CommandClass extends RemoteCommand<infer Inputs, any, any> ? Inputs : never
+export type ResultOf<CommandClass> = CommandClass extends RemoteCommand<any, infer Result, any> ? Result : never
+export type ErrorOf<CommandClass> = CommandClass extends RemoteCommand<any, any, infer Error> ? Error : never
+
+export interface RemoteCommandConstructor<CommandT extends RemoteCommand<any, any, any>> {
+  new (inputs: InputsOf<CommandT>): CommandT
+  fullCommandName: string
+}

data/templates/hooks/useQuery.ts

@@ -0,0 +1,75 @@
+import type RemoteCommand from '../base/RemoteCommand'
+import { type Outcome } from '../base/Outcome'
+import {
+  type InputsOf, type ResultOf, type ErrorOf, type RemoteCommandConstructor
+} from '../base/RemoteCommandTypes'
+import type Query from '../base/Query'
+import { useState, useRef, useEffect } from 'react'
+import { getQuery } from '../base/QueryCache'
+
+interface QueryState<CommandT extends RemoteCommand<any, any, any>> {
+  isLoading: boolean
+  isPending: boolean
+  isFailure: boolean
+  isSuccess: boolean
+  isError: boolean
+  outcome: null | Outcome<ResultOf<CommandT>, ErrorOf<CommandT>>
+  result: null | ResultOf<CommandT>
+  errors: null | Array<ErrorOf<CommandT>>
+  failure: any
+  setInputs: (inputs: InputsOf<CommandT>) => void
+  setDirty: () => void
+}
+
+function queryToQueryState<CommandT extends RemoteCommand<any, any, any>> (
+  query: Query<CommandT>
+): QueryState<CommandT> {
+  return {
+    isLoading: query.isLoading,
+    isPending: query.isPending,
+    isFailure: query.isFailure,
+    isSuccess: query.isSuccess,
+    isError: query.isError,
+    outcome: query.outcome,
+    result: query.result,
+    errors: query.errors,
+    failure: query.failure,
+    setInputs: (inputs: InputsOf<CommandT>) => { query.setInputs(inputs) },
+    setDirty: () => { query.setDirty() }
+  }
+}
+
+export default function useQuery<CommandT extends RemoteCommand<any, any, any>> (
+  CommandClass: RemoteCommandConstructor<CommandT>,
+  inputs: InputsOf<CommandT> | undefined = undefined
+): QueryState<CommandT> {
+  const queryRef = useRef<Query<CommandT>>(null)
+
+  let query = queryRef.current
+
+  if (query == null) {
+    if (arguments.length === 2) {
+      query = getQuery(CommandClass, inputs as InputsOf<CommandT>)
+    } else {
+      query = getQuery(CommandClass)
+    }
+
+    queryRef.current = query
+  }
+
+  useEffect(() => {
+    const unsubscribe = query?.onChange(() => {
+      if (query != null) { // just here to satisfy type checker
+        setQueryState(queryToQueryState<CommandT>(query))
+      }
+    })
+
+    return unsubscribe
+  }, [query])
+
+  const [queryState, setQueryState] = useState<QueryState<CommandT>>(
+    queryToQueryState<CommandT>(query)
+  )
+
+  return queryState
+}

data/templates/setup.ts.erb

@@ -0,0 +1,5 @@
+import { GetCurrentUser } from './BlogWww/GetCurrentUser'
+import { getQuery } from './base/QueryCache'
+import { setGetCurrentUserQuery } from './Foobara/Auth/utils/accessTokens'
+
+setGetCurrentUserQuery(getQuery(GetCurrentUser, undefined))

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara-typescript-remote-command-generator
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.21
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 2025-05-03 00:00:00.000000000 Z
+date: 2025-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foobara-files-generator
@@ -50,6 +50,7 @@ files:
 - src/remote_generator/services/auth/refresh_login_generator.rb
 - src/remote_generator/services/auth/requires_auth_command_generator.rb
 - src/remote_generator/services/auth/requires_auth_generator.rb
+- src/remote_generator/services/auth/setup_generator.rb
 - src/remote_generator/services/command_errors_generator.rb
 - src/remote_generator/services/command_errors_index_generator.rb
 - src/remote_generator/services/command_generator.rb
@@ -108,7 +109,12 @@ files:
 - templates/base/Error.ts
 - templates/base/Model.ts
 - templates/base/Outcome.ts
+- templates/base/Query.ts
+- templates/base/QueryCache.ts
 - templates/base/RemoteCommand.ts
+- templates/base/RemoteCommandTypes.ts
+- templates/hooks/useQuery.ts
+- templates/setup.ts.erb
 homepage: https://github.com/foobara/typescript-remote-command-generator
 licenses:
 - Apache-2.0