foobara-typescript-remote-command-generator 0.0.1

data/templates/Command.ts.erb

@@ -0,0 +1,11 @@
+import RemoteCommand from "<%= path_to_root %>base/RemoteCommand"
+
+import Inputs from "./Inputs"
+import Result from "./Result"
+import { Error } from "./Errors"
+
+export class <%= command_name %> extends RemoteCommand<Inputs, Result, Error> {
+  static readonly organizationName = "<%= organization_name %>"
+  static readonly domainName = "<%= domain_name %>"
+  static readonly commandName = "<%= command_name %>"
+}

data/templates/Domain/config.ts.erb

@@ -0,0 +1,16 @@
+let _urlBase = process.env.REACT_APP_FOOBARA_GLOBAL_URL_BASE
+
+const config = {
+  get urlBase(): string {
+    if (_urlBase === undefined) {
+      throw new Error("urlBase is not set and REACT_APP_FOOBARA_GLOBAL_URL_BASE is undefined")
+    }
+
+    return _urlBase
+  },
+  set urlBase(urlBase: string) {
+    _urlBase = urlBase
+  }
+}
+
+export default config

data/templates/Domain.ts.erb

@@ -0,0 +1,17 @@
+export * as config from "./config"
+
+export const isGlobal = <%= global? %>
+export const organizationName = "<%= organization_name %>"
+export const domainName = "<%= domain_name %>"
+
+<% command_generators.each do |command| %>
+export <%= command.import_destructure %> from "<%= path_to_root %><%= command.import_path %>"
+<% if command.command_errors_index_generator.applicable? %>
+export <%= command.command_errors_index_generator.import_destructure %> from "<%= path_to_root %><%= command.command_errors_index_generator.import_path %>"
+<% end %>
+<% end %>
+
+// TODO: put these on an entities module so that commands can be the only top-level interface.
+<% entity_generators.each do |entity| %>
+export <%= entity.import_destructure %> from "<%= path_to_root %><%= entity.import_path %>"
+<% end %>

data/templates/Entity/Aggregate.ts.erb

@@ -0,0 +1,18 @@
+import {
+  <%= entity_name %>AttributesType
+} from "./Ambiguous"
+import { Loaded<%= entity_name %> } from "./Loaded"
+<% dependency_roots.each do |dependency_root| %>
+import { <%= dependency_root.ts_instance_name %> } from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+export interface <%= entity_name %>AggregateAttributesType extends <%= entity_name %>AttributesType <%= attributes_type_ts_type %>
+
+export class <%= entity_name %>Aggregate extends Loaded<%= entity_name %><<%= entity_name %>AggregateAttributesType> {
+  <% if has_associations? %>
+  /* eslint-disable @typescript-eslint/class-literal-property-style */
+  get isAtom (): false { return false }
+  get isAggregate (): true { return true }
+  /* eslint-enable @typescript-eslint/class-literal-property-style */
+  <% end %>
+}

data/templates/Entity/Ambiguous.ts.erb

@@ -0,0 +1,30 @@
+import { Entity } from "<%= path_to_root %>base/Entity"
+<% dependency_roots.each do |dependency_root| %>
+import { <%= dependency_root.scoped_name %> } from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+export type <%= entity_name %>PrimaryKeyType = <%= primary_key_ts_type %>
+export const <%= entity_name_downcase %>PrimaryKeyAttributeName: "<%= primary_key_name %>" = "<%= primary_key_name %>"
+export interface <%= entity_name %>AttributesType <%= attributes_type_ts_type %>
+
+export class <%= entity_name %><
+  AttributesType extends <%= entity_name %>AttributesType = <%= entity_name %>AttributesType
+> extends Entity<<%= entity_name %>PrimaryKeyType, AttributesType> {
+  static readonly modelName: string = "<%= entity_name %>"
+  static readonly entityName: string = "<%= entity_name %>"
+  static readonly primaryKeyAttributeName: "<%= primary_key_name %>" = "<%= primary_key_name %>"
+
+  get <%= primary_key_name %> (): <%= entity_name %>PrimaryKeyType {
+    return this.primaryKey
+  }
+
+  get associationPropertyPaths (): string[][] { return <%= association_property_paths_ts %> }
+  readonly hasAssociations: <%= has_associations? %> = <%= has_associations? %>
+
+  <% attribute_names.each do |attribute_name| %>
+  get <%= attribute_name %> (): AttributesType["<%= attribute_name %>"] {
+    return this.readAttribute("<%= attribute_name %>")
+  }
+  <% end %>
+
+}

data/templates/Entity/Atom.ts.erb

@@ -0,0 +1,18 @@
+import {
+  <%= entity_name %>AttributesType
+} from "./Ambiguous"
+import { Loaded<%= entity_name %> } from "./Loaded"
+<% dependency_roots.each do |dependency_root| %>
+import { <%= dependency_root.ts_instance_name %> } from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+export interface <%= entity_name %>AtomAttributesType extends <%= entity_name %>AttributesType <%= atom_attributes_ts_type %>
+
+export class <%= entity_name %>Atom extends Loaded<%= entity_name %><<%= entity_name %>AtomAttributesType> {
+  <% if has_associations? %>
+  /* eslint-disable @typescript-eslint/class-literal-property-style */
+  get isAtom (): true { return true }
+  get isAggregate (): false { return false }
+  /* eslint-enable @typescript-eslint/class-literal-property-style */
+  <% end %>
+}

data/templates/Entity/Loaded.ts.erb

@@ -0,0 +1,14 @@
+import {
+  <%= entity_name %>,
+  <%= entity_name %>AttributesType
+} from "./Ambiguous"
+
+export class Loaded<%= entity_name %><T extends <%= entity_name %>AttributesType = <%= entity_name %>AttributesType> extends <%= entity_name %><T> {
+  readonly isLoaded: true = true
+  <% unless has_associations? %>
+/* eslint-disable @typescript-eslint/class-literal-property-style */
+  get isAtom (): true { return true }
+  get isAggregate (): true { return true }
+/* eslint-enable @typescript-eslint/class-literal-property-style */
+  <% end %>
+}

data/templates/Entity/Unloaded.ts.erb

@@ -0,0 +1,18 @@
+import { Never } from "<%= path_to_root %>base/Entity"
+import {
+  <%= entity_name %>,
+  //<%= entity_name %>PrimaryKeyType
+  <%= entity_name %>AttributesType
+} from "./Ambiguous"
+
+export type Unloaded<%= entity_name %>AttributesType = Never<<%= entity_name %>AttributesType>
+
+export class Unloaded<%= entity_name %> extends <%= entity_name %><Unloaded<%= entity_name %>AttributesType> {
+  /*
+  constructor(id: <%= entity_name %>PrimaryKeyType) {
+    super(id, {})
+  }
+  */
+
+  readonly isLoaded: false = false
+}

data/templates/EntityVariants.ts.erb

@@ -0,0 +1,40 @@
+import {
+  <%= entity_name %>,
+  <%= entity_name %>PrimaryKeyType,
+  <%= entity_name_downcase %>PrimaryKeyAttributeName,
+  <%= entity_name %>AttributesType
+} from "./<%= entity_name %>/Ambiguous"
+import {
+  Unloaded<%= entity_name %>,
+  Unloaded<%= entity_name %>AttributesType
+} from "./<%= entity_name %>/Unloaded"
+import {
+  Loaded<%= entity_name %>
+} from "./<%= entity_name %>/Loaded"
+
+<% if has_associations? %>
+import {
+  <%= entity_name %>Atom,
+  <%= entity_name %>AtomAttributesType
+} from "./<%= entity_name %>/Atom"
+import {
+  <%= entity_name %>Aggregate,
+  <%= entity_name %>AggregateAttributesType
+} from "./<%= entity_name %>/Aggregate"
+<% end %>
+
+export {
+  <%= entity_name %>,
+  type <%= entity_name %>AttributesType,
+  Unloaded<%= entity_name %>,
+  type Unloaded<%= entity_name %>AttributesType,
+  Loaded<%= entity_name %>,
+<% if has_associations? %>
+  <%= entity_name %>Atom,
+  type <%= entity_name %>AtomAttributesType,
+  <%= entity_name %>Aggregate,
+  type <%= entity_name %>AggregateAttributesType,
+<% end %>
+  type <%= entity_name %>PrimaryKeyType,
+  <%= entity_name_downcase %>PrimaryKeyAttributeName
+}

data/templates/Error.ts.erb

@@ -0,0 +1,8 @@
+<% dependency_roots.each do |dependency_root| %>
+import { <%= dependency_root.scoped_name %> } from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+import { <%= error_base_class %> } from "<%= path_to_root %>base/Error"
+
+export class <%= error_name %> extends <%= error_base_class %><<%= context_ts_type %>> {
+}

data/templates/Model/Aggregate.ts.erb

@@ -0,0 +1,12 @@
+import {
+  <%= model_name %>,
+  <%= model_name %>AttributesType
+} from "./<%= model_name %>"
+<% dependency_roots.each do |dependency_root| %>
+import { <%= dependency_root.ts_instance_name %> } from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+export interface <%= model_name %>AggregateAttributesType extends <%= model_name %>AttributesType <%= attributes_type_ts_type %>
+
+export class <%= model_name %>Aggregate extends <%= model_name %><<%= model_name %>AggregateAttributesType> {
+}

data/templates/Model/Atom.ts.erb

@@ -0,0 +1,12 @@
+import {
+  <%= model_name %>,
+  <%= model_name %>AttributesType
+} from "./<%= model_name %>"
+<% dependency_roots.each do |dependency_root| %>
+import { <%= dependency_root.ts_instance_name %> } from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+export interface <%= model_name %>AtomAttributesType extends <%= model_name %>AttributesType <%= atom_attributes_ts_type %>
+
+export class <%= model_name %>Atom extends <%= model_name %><<%= model_name %>AtomAttributesType> {
+}

data/templates/Model/Model.ts.erb

@@ -0,0 +1,18 @@
+import { Model } from "<%= path_to_root %>base/Model"
+<% dependency_roots.each do |dependency_root| %>
+import { <%= dependency_root.scoped_name %> } from "<%= path_to_root %><%= dependency_root.import_path %>"
+<% end %>
+
+export interface <%= model_name %>AttributesType <%= attributes_type_ts_type %>
+
+export class <%= model_name %><
+  AttributesType extends <%= model_name %>AttributesType = <%= model_name %>AttributesType
+> extends Model<AttributesType> {
+  static readonly modelName: string = "<%= model_name %>"
+
+  <% attribute_names.each do |attribute_name| %>
+  get <%= attribute_name %> (): AttributesType["<%= attribute_name %>"] {
+    return this.readAttribute("<%= attribute_name %>")
+  }
+  <% end %>
+}

data/templates/ModelVariants.ts.erb

@@ -0,0 +1,26 @@
+import {
+  <%= model_name %>,
+  <%= model_name %>AttributesType
+} from "./<%= model_name %>/<%= model_name %>"
+
+<% if has_associations? %>
+import {
+  <%= model_name %>Atom,
+  <%= model_name %>AtomAttributesType
+} from "./<%= model_name %>/Atom"
+import {
+  <%= model_name %>Aggregate,
+  <%= model_name %>AggregateAttributesType
+} from "./<%= model_name %>/Aggregate"
+<% end %>
+
+export {
+  <%= model_name %>,
+  type <%= model_name %>AttributesType,
+<% if has_associations? %>
+  <%= model_name %>Atom,
+  type <%= model_name %>AtomAttributesType,
+  <%= model_name %>Aggregate,
+  type <%= model_name %>AggregateAttributesType,
+<% end %>
+}

data/templates/Organization/config.ts.erb

@@ -0,0 +1,16 @@
+let _urlBase = process.env.REACT_APP_FOOBARA_GLOBAL_URL_BASE
+
+const config = {
+  get urlBase(): string {
+    if (_urlBase === undefined) {
+      throw new Error("urlBase is not set and REACT_APP_FOOBARA_GLOBAL_URL_BASE is undefined")
+    }
+
+    return _urlBase
+  },
+  set urlBase(urlBase: string) {
+    _urlBase = urlBase
+  }
+}
+
+export default config

data/templates/Organization.ts.erb

@@ -0,0 +1,8 @@
+export * as config from "./config"
+
+<% domain_generators.each do |domain| %>
+export <%= domain.import_destructure %> from "<%= path_to_root %><%= domain.import_path %>"
+<% end %>
+
+export const isGlobal = <%= global? %>
+export const organizationName = "<%= organization_name %>"

data/templates/base/DataPath.ts

@@ -0,0 +1,49 @@
+function flatten (array: any[][]): any[] {
+  return array.reduce((acc, val) => acc.concat(val), [])
+}
+
+function uniq<T> (array: T[]): T[] {
+  return Array.from(new Set(array));
+}
+
+function compact (array: any[]): any[] {
+  return array.filter(item => item !== null && item !== undefined)
+}
+
+function _valuesAt<T extends (Record<string, any> | any[])> (objects: T[], path: Array<string | number>): any[] {
+  if (path.length === 0) return objects
+
+  const [pathPart, ...remainingParts] = path
+
+  let newObjects: any[]
+
+  if (pathPart === '#') {
+    const flat = flatten(objects as any[][])
+    newObjects = uniq(flat)
+  } else if (typeof pathPart === 'number') {
+    newObjects = compact(objects.map((object: T) => {
+      if (Array.isArray(object)) {
+        return object[pathPart]
+      } else {
+        throw new Error(`Cannot access index ${pathPart} of object because it's not an array`)
+      }
+    }))
+  } else if (typeof pathPart === 'string') {
+    newObjects = compact(objects.map((object: T) => {
+      if (typeof object === 'object' && object !== null) {
+        const record: Record<string, any> = object
+        return record[pathPart]
+      } else {
+        throw new Error(`Bad object and part: ${pathPart}`)
+      }
+    }))
+  } else {
+    throw new Error(`Bad path part: ${typeof pathPart}`)
+  }
+
+  return _valuesAt(newObjects, remainingParts)
+}
+
+export function valuesAt<T extends Record<string, any> | any[]> (object: T, path: string[]): any[] {
+  return _valuesAt([object], path)
+}

data/templates/base/Entity.ts

@@ -0,0 +1,87 @@
+import { Model } from './Model';
+import { valuesAt } from './DataPath';
+
+export type Never<T> = {[P in keyof T]: never};
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export type EntityPrimaryKeyType = number | string
+
+export abstract class Entity<PrimaryKeyType extends EntityPrimaryKeyType, AttributesType>
+  extends Model<AttributesType> {
+  static readonly entityName: string
+  static readonly primaryKeyAttributeName: string
+
+  readonly primaryKey: PrimaryKeyType
+  readonly isLoaded: boolean
+
+  abstract get hasAssociations(): boolean
+  abstract get associationPropertyPaths (): string[][]
+
+  constructor(primaryKey: PrimaryKeyType, attributes: AttributesType) {
+    super(attributes)
+    this.primaryKey = primaryKey
+    this.isLoaded = attributes !== undefined
+  }
+
+  /* Can we make this work or not?
+  getConstructor(): EntityConstructor<PrimaryKeyType, AttributesType> {
+    return this.constructor as EntityConstructor<PrimaryKeyType, AttributesType>;
+  }
+  */
+  entitiesAt(path: string[]): Entity<EntityPrimaryKeyType, Record<string, any>>[] {
+    return valuesAt(this, path).filter(item => item !== undefined) as Entity<EntityPrimaryKeyType, Record<string, any>>[]
+  }
+
+  get isAtom(): boolean {
+    if (!this.isLoaded) {
+      throw new Error("Record is not loaded so can't check if it's an atom")
+    }
+
+    if (!this.hasAssociations) {
+      return true
+    }
+
+    for (const path of this.associationPropertyPaths) {
+      for (const record of this.entitiesAt(path)) {
+        if (record.isLoaded) {
+          return false
+        }
+      }
+    }
+
+    return true
+  }
+
+  get isAggregate(): boolean {
+    if (!this.isLoaded) {
+      throw new Error("Record is not loaded so can't check if it's an aggregate")
+    }
+
+    if (!this.hasAssociations) {
+      return true
+    }
+
+    for (const path of this.associationPropertyPaths) {
+      for (const record of this.entitiesAt(path)) {
+        if (!record.isLoaded) {
+          return false
+        }
+
+        if (!record.isAggregate) {
+          return false
+        }
+      }
+    }
+
+    return true
+  }
+  get attributes(): AttributesType {
+    if (!this.isLoaded) {
+      throw new Error(
+        `Cannot read attributes because :${this.primaryKey} is not a loaded record`
+      )
+    }
+
+    return this._attributes
+  }
+}

data/templates/base/Error.ts

@@ -0,0 +1,29 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
+export abstract class FoobaraError<contextT = any> {
+  static readonly symbol: string
+  static readonly category: 'data' | 'runtime'
+
+  readonly key: string
+  readonly path: string[]
+  readonly runtime_path: string[]
+  readonly message: string
+  readonly context: contextT
+
+  constructor ({ key, path, runtime_path, message, context }:
+                 { key: string, path?: string[], runtime_path?: string[], message: string, context: contextT }) {
+    this.key = key
+    this.path = path ?? []
+    this.runtime_path = runtime_path ?? []
+    this.message = message
+    this.context = context
+  }
+}
+
+export class DataError<contextT extends Record<string, any>> extends FoobaraError<contextT> {
+  static readonly category: 'data' = 'data'
+}
+
+export class RuntimeError<contextT extends Record<string, any>> extends FoobaraError<contextT> {
+  static readonly category: 'runtime' = 'runtime'
+}

data/templates/base/Model.ts

@@ -0,0 +1,24 @@
+export abstract class Model<AttributesType> {
+  static readonly modelName: string
+  readonly _attributes: AttributesType
+
+
+  constructor(attributes: AttributesType) {
+    this._attributes = attributes
+  }
+
+
+  /* Can we make this work or not?
+  getConstructor(): EntityConstructor<PrimaryKeyType, AttributesType> {
+    return this.constructor as EntityConstructor<PrimaryKeyType, AttributesType>;
+  }
+  */
+
+  get attributes(): AttributesType {
+    return this._attributes
+  }
+
+  readAttribute<T extends keyof this["_attributes"]>(attributeName: T): this["_attributes"][T] {
+    return (this.attributes as unknown as this["_attributes"])[attributeName]
+  }
+}

data/templates/base/Outcome.ts

@@ -0,0 +1,42 @@
+import { type FoobaraError } from './Error'
+
+export class Outcome<Result, OutcomeError extends FoobaraError> {
+  readonly result?: Result
+  readonly errors: OutcomeError[] = []
+  readonly _isSuccess: boolean
+
+  constructor (result?: Result, errors?: OutcomeError[]) {
+    this.result = result
+    if (errors != null) {
+      this.errors = errors
+    }
+    this._isSuccess = errors == null || errors.length === 0
+  }
+
+  isSuccess (): this is SuccessfulOutcome<Result, OutcomeError> {
+    return this._isSuccess
+  }
+
+  get errorMessage (): string {
+    return this.errors.map(e => e.message).join(', ')
+  }
+}
+
+export class SuccessfulOutcome<Result, OutcomeError extends FoobaraError> extends Outcome<Result, OutcomeError> {
+  readonly _isSuccess: true = true
+  readonly errors: OutcomeError[] = []
+  readonly result: Result
+
+  constructor (result: Result) {
+    super(result, [])
+    this.result = result
+  }
+}
+
+export class ErrorOutcome<Result, OutcomeError extends FoobaraError> extends Outcome<Result, OutcomeError> {
+  readonly _isSuccess: false = false
+
+  constructor (errors: OutcomeError[]) {
+    super(undefined, errors)
+  }
+}

data/templates/base/RemoteCommand.ts

@@ -0,0 +1,87 @@
+import { type Outcome, SuccessfulOutcome, ErrorOutcome } from './Outcome'
+import { type FoobaraError } from './Error'
+
+export default abstract class RemoteCommand<Inputs, Result, CommandError extends FoobaraError> {
+  static _urlBase: string | undefined
+  static commandName: string
+  static organizationName: string
+  static domainName: string
+
+  // TODO: make use of domain's config instead of process.env directly.
+  static get urlBase (): string {
+    let base = this._urlBase
+
+    if (base == null) {
+      base = process.env.REACT_APP_FOOBARA_GLOBAL_URL_BASE
+    }
+
+    if (base == null) {
+      throw new Error("urlBase is not set and REACT_APP_FOOBARA_GLOBAL_URL_BASE is undefined")
+    }
+
+    return base
+  }
+
+  static set urlBase (urlBase: string) {
+    this._urlBase = urlBase
+  }
+
+  get organizationName (): string {
+    return (this.constructor as typeof RemoteCommand<Inputs, Result, CommandError>).organizationName
+  }
+
+  get domainName (): string {
+    return (this.constructor as typeof RemoteCommand<Inputs, Result, CommandError>).domainName
+  }
+
+  inputs: Inputs
+
+  constructor (inputs: Inputs) {
+    this.inputs = inputs
+  }
+
+  get commandName (): string {
+    return (this.constructor as typeof RemoteCommand<Inputs, Result, CommandError>).commandName
+  }
+
+  get urlBase (): string {
+    return (this.constructor as typeof RemoteCommand<Inputs, Result, CommandError>).urlBase
+  }
+
+  static get fullCommandName (): string {
+    const path = []
+
+    if (this.organizationName != null && this.organizationName !== "GlobalOrganization") {
+      path.push(this.organizationName)
+    }
+    if (this.domainName != null && this.domainName !== "GlobalDomain") {
+      path.push(this.domainName)
+    }
+    if (this.commandName != null) {
+      path.push(this.commandName)
+    }
+    return path.join('::')
+  }
+
+  get fullCommandName (): string {
+    return (this.constructor as typeof RemoteCommand<Inputs, Result, CommandError>).fullCommandName
+  }
+
+  async run (): Promise<Outcome<Result, CommandError>> {
+    const url = `${this.urlBase}/run/${this.fullCommandName}`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(this.inputs)
+    })
+
+    if (response.ok) {
+      return new SuccessfulOutcome<Result, CommandError>(await response.json())
+    } else if (response.status === 422) {
+      return new ErrorOutcome<Result, CommandError>(await response.json())
+    } else {
+      throw new Error(`not sure how to handle ${await response.text()}`)
+    }
+  }
+}