@liquidmetal-ai/drizzle 0.0.1

package/src/appify/build.ts

@@ -0,0 +1,783 @@
+import {
+  ArrayNode,
+  AssignmentNode,
+  BlockNode,
+  fmt,
+  NodeType,
+  StanzaNode,
+  TokenBoolean,
+  TokenNumber,
+  TokenString,
+} from './parse.js';
+
+export function valueOf(token: TokenString): string;
+export function valueOf(token: TokenNumber): number;
+export function valueOf(token: TokenBoolean): boolean;
+
+// valueOf extracts the value of a token in the appropriate format.
+export function valueOf(token: TokenString | TokenNumber | TokenBoolean): string | number | boolean {
+  if (token.type === 'number') {
+    return Number(token.value);
+  }
+  if (token.type === 'boolean') {
+    return token.value == 'true';
+  }
+  if (token.type === 'string') {
+    return token.value.slice(1, -1);
+  }
+  throw new Error(`unexpected token type`);
+}
+
+export interface ConfigObject {
+  line: number;
+  column: number;
+  start: number;
+  end: number;
+}
+
+export class ConfigError {
+  message: string;
+  line: number;
+  column: number;
+  start: number;
+  end: number;
+
+  constructor(message: string, obj: ConfigObject) {
+    this.message = message;
+    this.line = obj.line;
+    this.column = obj.column;
+    this.start = obj.start;
+    this.end = obj.end;
+  }
+}
+
+export function buildManifest(node: BlockNode): [Application[], ConfigError[]] {
+  const applications: Application[] = [];
+  const errors: ConfigError[] = [];
+
+  for (const child of node.children) {
+    switch (child.type) {
+      case 'stanza':
+        if (child.name === 'application') {
+          buildStanza(buildApplication, child, applications, errors);
+        } else {
+          errors.push({ message: 'expected application', ...child });
+        }
+        break;
+      case 'comment':
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: 'expected application', ...child });
+    }
+  }
+  return [applications, errors];
+}
+
+// buildName1 is a helper function for parsing a name from a stanza
+// node arguments and asserting there should only be 1, string
+// argument.
+function buildName1(node: StanzaNode): [TokenString, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const invalid = {
+    type: 'string',
+    value: '"<invalid>"',
+    line: node.line,
+    column: node.column,
+    start: node.start,
+    end: node.block?.start || node.end,
+  } as TokenString;
+  if (node.args.length === 0) {
+    errors.push({ message: 'expected name', ...node });
+    return [invalid, errors];
+  }
+  if (node.args.length > 1) {
+    errors.push({ message: 'unexpected additional args', ...node });
+  }
+  if (node.args[0]?.type !== 'string') {
+    errors.push({ message: 'expected string', ...node.args[0]! });
+    return [invalid, errors];
+  }
+  return [node.args[0], errors];
+}
+
+// buildStanza is a helper to build different stanzas into a parent
+// object.
+function buildStanza<T>(
+  handler: (child: StanzaNode) => [T | undefined, ConfigError[]],
+  child: StanzaNode,
+  into: T[],
+  errors: ConfigError[],
+) {
+  const [buildItem, buildErrors] = handler(child);
+  if (buildItem) {
+    into.push(buildItem);
+  }
+  errors.push(...buildErrors);
+}
+
+// buildAssignment is a helper to build assignments into an object. It
+// validates type, throws errors on duplicate assignment, and makes
+// sure the field exists on the object and is the right type.
+function buildAssignment<T>(obj: T, field: keyof T, expected: NodeType, child: AssignmentNode, errors: ConfigError[]) {
+  if (obj[field]) {
+    // FYI: field name in manifest is not necessarily field name on IR
+    // because of snake_case vs camelCase. So we use the left-hand
+    // side of the assignment in the error.
+    errors.push({ message: `duplicate ${fmt(child.key)} assignment ${fmt(child.value)}`, ...child.key });
+  }
+  if (child.value.type !== expected) {
+    errors.push({ message: `expected ${expected}`, ...child.value });
+  } else {
+    // We could get fancy with the type system, but for the sake of
+    // GTD, just cast because we know we're the right type.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    obj[field] = child.value as any;
+  }
+}
+
+export function buildApplication(node: StanzaNode): [Application | undefined, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  // Build out the application name.
+  const [name, nameErrors] = buildName1(node);
+  errors.push(...nameErrors);
+  const app = new Application(name, node);
+  const children = node.block ? node.block.children : [];
+
+  // Iterate over child nodes
+  for (const child of children) {
+    switch (child.type) {
+      case 'stanza':
+        switch (child.name) {
+          case 'service':
+            buildStanza(buildService, child, app.service, errors);
+            break;
+          case 'env':
+            buildStanza(buildEnv, child, app.env, errors);
+            break;
+          case 'observer':
+            buildStanza(buildObserver, child, app.observer, errors);
+            break;
+          case 'actor':
+            buildStanza(buildActor, child, app.actor, errors);
+            break;
+          case 'bucket':
+            buildStanza(buildBucket, child, app.bucket, errors);
+            break;
+          case 'queue':
+            buildStanza(buildQueue, child, app.queue, errors);
+            break;
+          case 'vector_index':
+            buildStanza(buildVectorIndex, child, app.vectorIndex, errors);
+            break;
+          case 'sql_database':
+            buildStanza(buildSqlDatabase, child, app.sqlDatabase, errors);
+            break;
+          default:
+            errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        }
+        break;
+      case 'assignment':
+        errors.push({ message: 'unexpected assignment', ...child });
+        break;
+      case 'comment':
+        break;
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [app, errors];
+}
+
+function buildService(stanza: StanzaNode): [Service, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const service = new Service(name, stanza);
+  const children = stanza.block ? stanza.block.children : [];
+
+  for (const child of children) {
+    switch (child.type) {
+      case 'stanza':
+        switch (child.name) {
+          case 'route':
+            buildStanza(buildRoute, child, service.routes, errors);
+            break;
+          case 'domain':
+            buildStanza(buildDomain, child, service.domains, errors);
+            break;
+          case 'binding':
+            buildStanza(buildBinding, child, service.bindings, errors);
+            break;
+          case 'env':
+            buildStanza(buildEnv, child, service.env, errors);
+            break;
+          default:
+            errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        }
+        break;
+      case 'assignment':
+        switch (child.key.value) {
+          case 'visibility':
+            buildAssignment(service, 'visibility', 'string', child, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
+        break;
+      case 'comment':
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: 'unexpected node', ...child });
+    }
+  }
+  return [service, errors];
+}
+
+function buildBucket(stanza: StanzaNode): [Bucket, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const bucket = new Bucket(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case 'stanza':
+        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        break;
+      case 'assignment':
+        switch (child.key.value) {
+          case 'visibility':
+            buildAssignment(bucket, 'visibility', 'string', child, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
+        break;
+      case 'comment':
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [bucket, errors];
+}
+
+function buildQueue(stanza: StanzaNode): [Queue, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const queue = new Queue(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case 'stanza':
+        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        break;
+      case 'assignment':
+        switch (child.key.value) {
+          case 'visibility':
+            buildAssignment(queue, 'visibility', 'string', child, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
+        break;
+      case 'comment':
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [queue, errors];
+}
+
+function buildVectorIndex(stanza: StanzaNode): [Bucket, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const bucket = new VectorIndex(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case 'stanza':
+        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        break;
+      case 'assignment':
+        switch (child.key.value) {
+          case 'visibility':
+            buildAssignment(bucket, 'visibility', 'string', child, errors);
+            break;
+          case 'dimension':
+            buildAssignment(bucket, 'dimension', 'number', child, errors);
+            break;
+          case 'metric':
+            buildAssignment(bucket, 'metric', 'string', child, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
+        break;
+      case 'comment':
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [bucket, errors];
+}
+
+function buildSqlDatabase(stanza: StanzaNode): [SqlDatabase, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const sqlDatabase = new SqlDatabase(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case 'stanza':
+        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        break;
+      case 'assignment':
+        switch (child.key.value) {
+          case 'visibility':
+            buildAssignment(sqlDatabase, 'visibility', 'string', child, errors);
+            break;
+          case 'schema':
+            buildAssignment(sqlDatabase, 'schema', 'string', child, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
+        break;
+      case 'comment':
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [sqlDatabase, errors];
+}
+
+function buildObserver(stanza: StanzaNode): [Observer, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const observer = new Observer(name as TokenString, stanza);
+  const children = stanza.block ? stanza.block.children : [];
+
+  for (const child of children) {
+    switch (child.type) {
+      case 'stanza':
+        switch (child.name) {
+          case 'source':
+            buildStanza(buildSource, child, observer.source, errors);
+            break;
+          case 'binding':
+            buildStanza(buildBinding, child, observer.bindings, errors);
+            break;
+          case 'env':
+            buildStanza(buildEnv, child, observer.env, errors);
+            break;
+          default:
+            errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        }
+        break;
+      case 'assignment':
+        errors.push({ message: 'unexpected assignment', ...child });
+        break;
+      case 'comment':
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [observer, errors];
+}
+
+function buildActor(stanza: StanzaNode): [Actor, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const actor = new Actor(name, stanza);
+  const children = stanza.block ? stanza.block.children : [];
+
+  for (const child of children) {
+    switch (child.type) {
+      case 'stanza':
+        switch (child.name) {
+          case 'binding':
+            buildStanza(buildBinding, child, actor.bindings, errors);
+            break;
+          case 'env':
+            buildStanza(buildEnv, child, actor.env, errors);
+            break;
+          default:
+            errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        }
+        break;
+      case 'assignment':
+        switch (child.key.value) {
+          case 'visibility':
+            buildAssignment(actor, 'visibility', 'string', child, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
+        break;
+      case 'comment':
+        break;
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [actor, errors];
+}
+
+function buildSource(stanza: StanzaNode): [Source, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const source = new Source(stanza);
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === 'assignment') {
+      switch (child.key.value) {
+        case 'bucket':
+          buildAssignment(source, 'bucket', 'string', child, errors);
+          break;
+        case 'queue':
+          buildAssignment(source, 'queue', 'string', child, errors);
+          break;
+        case 'batch_size':
+          // Note the subtle difference between the field name in the
+          // IR and the manifest.
+          buildAssignment(source, 'batchSize', 'number', child, errors);
+          break;
+        case 'max_wait_time_ms':
+          // Note the subtle difference between the field name in the
+          // IR and the manifest.
+          buildAssignment(source, 'maxWaitTimeMs', 'number', child, errors);
+          break;
+        case 'max_retries':
+          // Note the subtle difference between the field name in the
+          // IR and the manifest.
+          buildAssignment(source, 'maxRetries', 'number', child, errors);
+          break;
+        default:
+          errors.push({ message: 'unexpected assignment', ...child });
+      }
+    } else if (child.type === 'stanza') {
+      if (child.name === 'rule') {
+        source.rule = source.rule ?? [];
+        const rule = new Rule(child);
+        for (const ruleChild of child.block?.children ?? []) {
+          if (ruleChild.type === 'stanza') {
+            errors.push({ message: 'unexpected stanza', ...ruleChild });
+          } else if (ruleChild.type === 'assignment') {
+            switch (ruleChild.key.value) {
+              case 'actions':
+                buildAssignment(rule, 'actions', 'array', ruleChild, errors);
+                break;
+              case 'prefix':
+                buildAssignment(rule, 'prefix', 'string', ruleChild, errors);
+                break;
+              case 'suffix':
+                buildAssignment(rule, 'suffix', 'string', ruleChild, errors);
+                break;
+              default:
+                errors.push({ message: `unexpected assignment ${ruleChild.key}`, ...ruleChild });
+            }
+          }
+        }
+        source.rule.push(rule);
+      } else {
+        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+      }
+    }
+  }
+  return [source, errors];
+}
+
+function buildRoute(stanza: StanzaNode): [Route | undefined, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  if (stanza.args.length > 0) {
+    errors.push({ message: 'unexpected arguments/names', ...stanza });
+  }
+  const route = new Route(stanza);
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === 'assignment') {
+      switch (child.key.value) {
+        case 'zone':
+          buildAssignment(route, 'zone', 'string', child, errors);
+          break;
+        case 'pattern':
+          buildAssignment(route, 'pattern', 'string', child, errors);
+          break;
+        default:
+          errors.push({ message: `unexpected assignment ${child.key}`, ...child });
+      }
+    }
+  }
+  if (!route.zone) {
+    errors.push({ message: 'missing zone assignment', ...stanza });
+    return [undefined, errors];
+  }
+  if (!route.pattern) {
+    errors.push({ message: 'missing pattern assignment', ...stanza });
+    return [undefined, errors];
+  }
+  // TODO [ian]: validate zone and pattern contents.
+  return [route, errors];
+}
+
+function buildDomain(stanza: StanzaNode): [Domain, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  if (stanza.args.length > 0) {
+    errors.push({ message: 'unexpected arguments/names', ...stanza });
+  }
+  const domain = new Domain(stanza);
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === 'assignment') {
+      switch (child.key.value) {
+        case 'fqdn':
+          buildAssignment(domain, 'fqdn', 'string', child, errors);
+          break;
+        default:
+          errors.push({ message: `unexpected assignment ${child.key}`, ...child });
+      }
+    }
+  }
+  return [domain, errors];
+}
+
+function buildBinding(stanza: StanzaNode): [Binding, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const bindings: AssignmentNode[] = [];
+  function hasBinding(key: string) {
+    return bindings.some((binding) => binding.key.value === key);
+  }
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === 'assignment') {
+      if (hasBinding(child.key.value)) {
+        errors.push({ message: `duplicate binding ${child.key.value}`, ...child.key });
+      }
+      if (child.value.type === 'string') {
+        bindings.push(child);
+      } else {
+        errors.push({ message: 'expected string', ...child.value });
+      }
+    }
+  }
+  // TODO [ian]: validate key and value contents.
+  return [new Binding(bindings, stanza), errors];
+}
+
+function buildEnv(stanza: StanzaNode): [Env | undefined, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const env = new Env(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    if (child.type === 'assignment') {
+      switch (child.key.value) {
+        case 'secret':
+          buildAssignment(env, 'secret', 'boolean', child, errors);
+          break;
+        case 'default':
+          buildAssignment(env, 'default', 'string', child, errors);
+          break;
+        default:
+          errors.push({ message: `unexpected assignment ${child.key}`, ...child });
+      }
+    }
+  }
+  return [env, errors];
+}
+
+export class Application {
+  obj: ConfigObject;
+  name: TokenString;
+
+  service: Service[] = [];
+  observer: Observer[] = [];
+  actor: Actor[] = [];
+  bucket: Bucket[] = [];
+  queue: Queue[] = [];
+  env: Env[] = [];
+  sqlDatabase: SqlDatabase[] = [];
+  vectorIndex: VectorIndex[] = [];
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+
+  // Return all objects that require code handlers.
+  handlers(): (Service | Observer | Actor)[] {
+    return [...this.service, ...this.observer, ...this.actor];
+  }
+}
+
+export class Service {
+  obj: ConfigObject;
+  name: TokenString;
+  visibility?: TokenString;
+  routes: Route[] = [];
+  domains: Domain[] = [];
+  bindings: Binding[] = [];
+  env: Env[] = [];
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export class Actor {
+  obj: ConfigObject;
+  name: TokenString;
+  bindings: Binding[] = [];
+  env: Env[] = [];
+  visibility?: TokenString;
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export class Observer {
+  obj: ConfigObject;
+  name: TokenString;
+  source: Source[] = [];
+  bindings: Binding[] = [];
+  env: Env[] = [];
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export class Source {
+  obj: ConfigObject;
+
+  bucket?: TokenString;
+  rule?: Rule[];
+
+  queue?: TokenString;
+
+  batchSize?: TokenNumber;
+  maxWaitTimeMs?: TokenNumber;
+  maxRetries?: TokenNumber;
+
+  constructor(obj: ConfigObject) {
+    this.obj = obj;
+  }
+}
+
+export class Rule {
+  obj: ConfigObject;
+  actions?: ArrayNode;
+  prefix?: TokenString;
+  suffix?: TokenString;
+
+  constructor(obj: ConfigObject) {
+    this.obj = obj;
+  }
+}
+
+export class Route {
+  obj: ConfigObject;
+  zone?: TokenString;
+  pattern?: TokenString;
+
+  constructor(obj: ConfigObject) {
+    this.obj = obj;
+  }
+}
+
+export class Domain {
+  obj: ConfigObject;
+  fqdn?: TokenString;
+
+  constructor(obj: ConfigObject) {
+    this.obj = obj;
+  }
+}
+
+export class Binding {
+  bindings: AssignmentNode[];
+  obj: ConfigObject;
+
+  constructor(bindings: AssignmentNode[], obj: ConfigObject) {
+    this.bindings = bindings;
+    this.obj = obj;
+  }
+}
+
+export class Env {
+  name: TokenString;
+  secret?: TokenBoolean;
+  default?: TokenString;
+  obj: ConfigObject;
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export class Bucket {
+  name: TokenString;
+  visibility?: TokenString;
+  obj: ConfigObject;
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export class Queue {
+  name: TokenString;
+  visibility?: TokenString;
+  obj: ConfigObject;
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export class VectorIndex {
+  name: TokenString;
+  visibility?: TokenString;
+  dimension?: TokenNumber;
+  metric?: TokenString;
+  obj: ConfigObject;
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export class SqlDatabase {
+  name: TokenString;
+  schema?: TokenString;
+  visibility?: TokenString;
+  obj: ConfigObject;
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export const VISIBILITIES = ['none', 'public', 'private', 'protected', 'application', 'suite', 'tenant'] as const;
+export type Visibility = (typeof VISIBILITIES)[number];