@liquidmetal-ai/drizzle 0.2.3 → 0.2.9

package/eslint.config.mjs

@@ -1,3 +1,5 @@
 import repo_config from '@repo/eslint-config/eslint.config.mjs';
 
-export default repo_config.concat([]);
+export default repo_config.concat([
+       { ignores: ['src/liquidmetal/v1alpha1/*'] },
+]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liquidmetal-ai/drizzle",
-  "version": "0.2.3",
+  "version": "0.2.9",
   "description": "Raindrop core operational libraries",
   "main": "dist/index.js",
   "type": "module",
@@ -17,6 +17,7 @@
   "author": "Ian Sung-Schenck",
   "license": "MIT",
   "devDependencies": {
+    "@bufbuild/protobuf": "^2.2.3",
     "@changesets/cli": "^2.27.9",
     "@eslint/js": "^9.11.1",
     "@repo/eslint-config": "*",

package/src/appify/build.test.ts

@@ -147,9 +147,9 @@ application "my-app" {
 
   // Check the smartbucket properties
   const smartBucket = apps[0]!.smartBucket[0]!;
-  expect(valueOf(smartBucket.name)).toBe("my-smart-bucket");
+  expect(valueOf(smartBucket.name)).toBe('my-smart-bucket');
   expect(smartBucket.locationHint).toBeDefined();
-  expect(valueOf(smartBucket.locationHint!)).toBe("enam");
+  expect(valueOf(smartBucket.locationHint!)).toBe('enam');
 });
 
 test('smartbucket with invalid properties', () => {
@@ -194,3 +194,198 @@ application "foo" {
     },
   ]);
 });
+
+test('service with labels and annotations', () => {
+  const CONFIG = `
+application "my-app" {
+  service "my-service" {
+    labels = {
+      environment = "production"
+      team = "platform"
+    }
+
+    annotations = {
+      description = "Service for handling API requests"
+      version = "1.0.0"
+    }
+  }
+}
+`;
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+
+  const [apps, errors] = buildManifest(ast);
+  expect(errors).toEqual([]);
+
+  // Check that we have exactly one application with one service
+  expect(apps.length).toBe(1);
+  expect(apps[0]!.service.length).toBe(1);
+
+  // Check the service's labels and annotations
+  const service = apps[0]!.service[0]!;
+
+  // Verify labels
+  expect(service.labels).toBeDefined();
+  expect(service.labels!['environment']).toBe('production');
+  expect(service.labels!['team']).toBe('platform');
+
+  // Verify annotations
+  expect(service.annotations).toBeDefined();
+  expect(service.annotations!['description']).toBe('Service for handling API requests');
+  expect(service.annotations!['version']).toBe('1.0.0');
+});
+
+test('service with non-string labels and annotations', () => {
+  const CONFIG = `
+application "my-app" {
+  service "my-service" {
+    labels = {
+      environment = "production"
+      priority = 1
+      isActive = true
+    }
+
+    annotations = {
+      description = "Service for handling API requests"
+      maxInstances = 5
+    }
+  }
+}
+`;
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+
+  const [_, errors] = buildManifest(ast);
+
+  // Should have errors for non-string values
+  expect(errors.length).toBe(3);
+
+  // Check error messages
+  const errorMessages = errors.map((err) => err.message);
+  expect(errorMessages).toContain('labels must have string values, found non-string value for key "priority"');
+  expect(errorMessages).toContain('labels must have string values, found non-string value for key "isActive"');
+  expect(errorMessages).toContain('annotations must have string values, found non-string value for key "maxInstances"');
+});
+
+test('service with invalid labels type', () => {
+  const CONFIG = `
+application "my-app" {
+  service "my-service" {
+    labels = "not-an-object"
+  }
+}
+`;
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+
+  const [, errors] = buildManifest(ast);
+
+  // Should have one error for the invalid type
+  expect(errors.length).toBe(1);
+  expect(errors[0]!.message).toBe('labels must be an object');
+});
+
+test('actor with labels and annotations', () => {
+  const CONFIG = `
+application "my-app" {
+  actor "my-actor" {
+    labels = {
+      environment = "production"
+      team = "platform"
+    }
+
+    annotations = {
+      description = "Actor for processing background jobs"
+      version = "1.0.0"
+    }
+
+    visibility = "protected"
+  }
+}
+`;
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+
+  const [apps, errors] = buildManifest(ast);
+  expect(errors).toEqual([]);
+
+  // Check that we have exactly one application with one actor
+  expect(apps.length).toBe(1);
+  expect(apps[0]!.actor.length).toBe(1);
+
+  // Check the actor's labels and annotations
+  const actor = apps[0]!.actor[0]!;
+
+  // Verify labels
+  expect(actor.labels).toBeDefined();
+  expect(actor.labels!['environment']).toBe('production');
+  expect(actor.labels!['team']).toBe('platform');
+
+  // Verify annotations
+  expect(actor.annotations).toBeDefined();
+  expect(actor.annotations!['description']).toBe('Actor for processing background jobs');
+  expect(actor.annotations!['version']).toBe('1.0.0');
+
+  // Verify other properties still work
+  expect(valueOf(actor.visibility!)).toBe('protected');
+});
+
+test('observer with labels and annotations', () => {
+  const CONFIG = `
+application "my-app" {
+  bucket "my-bucket" {}
+
+  observer "my-observer" {
+    labels = {
+      environment = "production"
+      team = "platform"
+    }
+
+    annotations = {
+      description = "Observer for monitoring bucket changes"
+      version = "1.0.0"
+    }
+
+    source {
+      bucket = "my-bucket"
+    }
+  }
+}
+`;
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+
+  const [apps, errors] = buildManifest(ast);
+  expect(errors).toEqual([]);
+
+  // Check that we have exactly one application with one observer
+  expect(apps.length).toBe(1);
+  expect(apps[0]!.observer.length).toBe(1);
+
+  // Check the observer's labels and annotations
+  const observer = apps[0]!.observer[0]!;
+
+  // Verify labels
+  expect(observer.labels).toBeDefined();
+  expect(observer.labels!['environment']).toBe('production');
+  expect(observer.labels!['team']).toBe('platform');
+
+  // Verify annotations
+  expect(observer.annotations).toBeDefined();
+  expect(observer.annotations!['description']).toBe('Observer for monitoring bucket changes');
+  expect(observer.annotations!['version']).toBe('1.0.0');
+
+  // Verify source still works
+  expect(observer.source.length).toBe(1);
+  expect(valueOf(observer.source[0]!.bucket!)).toBe('my-bucket');
+});

package/src/appify/build.ts

@@ -136,6 +136,37 @@ function buildAssignment<T>(obj: T, field: keyof T, expected: NodeType, child: A
   }
 }
 
+// buildLabelset creates and validates a set of string-only key-value pairs,
+// reporting errors for any non-string values.
+function buildLabelset<T>(target: T, field: keyof T, child: AssignmentNode, errors: ConfigError[]): void {
+  if (child.value.type !== 'object') {
+    errors.push({ message: `${child.key.value} must be an object`, ...child });
+    return;
+  }
+
+  // Initialize the field as an empty object if it doesn't exist
+  if (!target[field]) {
+    target[field] = {} as T[keyof T];
+  }
+
+  // Get the object we're populating
+  const labelset = target[field] as Record<string, string>;
+
+  // Process each property in the object
+  for (const prop of child.value.properties) {
+    // Handle indentifiers and strings as object keys.
+    const key = prop.key.type === 'string' ? valueOf(prop.key) : prop.key.value;
+    if (prop.value.type === 'string') {
+      labelset[key] = valueOf(prop.value);
+    } else {
+      errors.push({
+        message: `${child.key.value} must have string values, found non-string value for key "${prop.key.value}"`,
+        ...prop.value,
+      });
+    }
+  }
+}
+
 export function buildApplication(node: StanzaNode): [Application | undefined, ConfigError[]] {
   const errors: ConfigError[] = [];
   // Build out the application name.
@@ -187,7 +218,16 @@ export function buildApplication(node: StanzaNode): [Application | undefined, Co
         }
         break;
       case 'assignment':
-        errors.push({ message: 'unexpected assignment', ...child });
+        switch (child.key.value) {
+          case 'labels':
+            buildLabelset(app, 'labels', child, errors);
+            break;
+          case 'annotations':
+            buildLabelset(app, 'annotations', child, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
         break;
       case 'comment':
         break;
@@ -232,6 +272,12 @@ function buildService(stanza: StanzaNode): [Service, ConfigError[]] {
           case 'visibility':
             buildAssignment(service, 'visibility', 'string', child, errors);
             break;
+          case 'labels':
+            buildLabelset(service, 'labels', child, errors);
+            break;
+          case 'annotations':
+            buildLabelset(service, 'annotations', child, errors);
+            break;
           default:
             errors.push({ message: 'unexpected assignment', ...child });
         }
@@ -452,7 +498,16 @@ function buildObserver(stanza: StanzaNode): [Observer, ConfigError[]] {
         }
         break;
       case 'assignment':
-        errors.push({ message: 'unexpected assignment', ...child });
+        switch (child.key.value) {
+          case 'labels':
+            buildLabelset(observer, 'labels', child, errors);
+            break;
+          case 'annotations':
+            buildLabelset(observer, 'annotations', child, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
         break;
       case 'comment':
       case 'newline':
@@ -490,6 +545,12 @@ function buildActor(stanza: StanzaNode): [Actor, ConfigError[]] {
           case 'visibility':
             buildAssignment(actor, 'visibility', 'string', child, errors);
             break;
+          case 'labels':
+            buildLabelset(actor, 'labels', child, errors);
+            break;
+          case 'annotations':
+            buildLabelset(actor, 'annotations', child, errors);
+            break;
           default:
             errors.push({ message: 'unexpected assignment', ...child });
         }
@@ -723,6 +784,8 @@ export class Application {
   vectorIndex: VectorIndex[] = [];
   kvStore: KvStore[] = [];
   smartBucket: SmartBucket[] = [];
+  labels: Record<string, string> = {};
+  annotations: Record<string, string> = {};
 
   constructor(name: TokenString, obj: ConfigObject) {
     this.name = name;
@@ -743,6 +806,8 @@ export class Service {
   domains: Domain[] = [];
   bindings: Binding[] = [];
   env: Env[] = [];
+  labels: Record<string, string> = {};
+  annotations: Record<string, string> = {};
 
   constructor(name: TokenString, obj: ConfigObject) {
     this.name = name;
@@ -756,6 +821,8 @@ export class Actor {
   bindings: Binding[] = [];
   env: Env[] = [];
   visibility?: TokenString;
+  labels: Record<string, string> = {};
+  annotations: Record<string, string> = {};
 
   constructor(name: TokenString, obj: ConfigObject) {
     this.name = name;
@@ -784,6 +851,8 @@ export class Observer {
   source: Source[] = [];
   bindings: Binding[] = [];
   env: Env[] = [];
+  labels: Record<string, string> = {};
+  annotations: Record<string, string> = {};
 
   constructor(name: TokenString, obj: ConfigObject) {
     this.name = name;

package/src/appify/parse.test.ts

@@ -34,7 +34,6 @@ actions = ['PutObject', 'DeleteObject']
 }
 }
 }
-}
 `;
 
 const CONFIG_FORMATTED = `
@@ -272,13 +271,38 @@ application "my-app" {
     }
     foo = {
       bar = "baz"
+      "qux" = 123
     }
   }
 }
 `);
   const parser = new Parser(tokenizer);
-  parser.parse();
+  const translator = new JSONTranslator();
+  const ast = parser.parse();
   expect(parser.errors).toHaveLength(0);
+
+  const result = translator.translate(ast);
+  expect(result).toEqual({
+    application: [
+      {
+        name: 'my-app',
+        service: [
+          {
+            name: 'my-service',
+            domain: [
+              {
+                fqdn: 'testymctestface.com',
+              },
+            ],
+            foo: {
+              bar: 'baz',
+              "\"qux\"": 123,
+            },
+          },
+        ],
+      },
+    ],
+  });
 });
 
 test('parse object with trash', () => {
@@ -334,3 +358,131 @@ application "my-app" {
   // Failed to close 3 curly braces.
   expect(parser.errors).toHaveLength(3);
 });
+
+test('translate objects', () => {
+  const CONFIG = `
+application "my-app" {
+  service "my-service" {
+    labels = {
+      environment = "production"
+      team = "platform"
+    }
+
+    annotations = {
+      description = "Service for handling API requests"
+      version = "1.0.0"
+    }
+  }
+}
+`;
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const translator = new JSONTranslator();
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+
+  const result = translator.translate(ast);
+  expect(result).toEqual({
+    application: [
+      {
+        name: 'my-app',
+        service: [
+          {
+            name: 'my-service',
+            labels: {
+              environment: 'production',
+              team: 'platform',
+            },
+            annotations: {
+              description: 'Service for handling API requests',
+              version: '1.0.0',
+            },
+          },
+        ],
+      },
+    ],
+  });
+});
+
+test('translate actor and observer objects', () => {
+  const CONFIG = `
+application "my-app" {
+  bucket "my-bucket" {}
+
+  actor "my-actor" {
+    labels = {
+      environment = "production"
+      team = "platform"
+    }
+    annotations = {
+      description = "Actor for background tasks"
+      version = "1.0.0"
+    }
+  }
+
+  observer "my-observer" {
+    labels = {
+      environment = "staging"
+      team = "platform"
+    }
+    annotations = {
+      description = "Observer for bucket events"
+      version = "1.0.0"
+    }
+    source {
+      bucket = "my-bucket"
+    }
+  }
+}
+`;
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const translator = new JSONTranslator();
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+
+  const result = translator.translate(ast);
+  expect(result).toEqual({
+    application: [
+      {
+        name: 'my-app',
+        bucket: [
+          {
+            name: 'my-bucket',
+          },
+        ],
+        actor: [
+          {
+            name: 'my-actor',
+            labels: {
+              environment: 'production',
+              team: 'platform',
+            },
+            annotations: {
+              description: 'Actor for background tasks',
+              version: '1.0.0',
+            },
+          },
+        ],
+        observer: [
+          {
+            name: 'my-observer',
+            labels: {
+              environment: 'staging',
+              team: 'platform',
+            },
+            annotations: {
+              description: 'Observer for bucket events',
+              version: '1.0.0',
+            },
+            source: [
+              {
+                bucket: 'my-bucket',
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  });
+});

package/src/appify/parse.ts

@@ -177,6 +177,7 @@ export type Node =
   | EmptyNode
   | ArrayNode
   | ObjectNode
+  | PropertyNode
   | Token;
 
 type BaseNode = {
@@ -212,9 +213,16 @@ export type ArrayNode = BaseNode & {
 
 export type ObjectNode = BaseNode & {
   type: 'object';
-  properties: AssignmentNode[];
+  properties: PropertyNode[];
 };
 
+export type PropertyNode = BaseNode & {
+  type: 'property';
+  operator: TokenOperator;
+  key: Extract<Token, { type: 'identifier' | 'string' }>;
+  value: ExpressionNode | Extract<Token, { type: 'string' | 'number' | 'boolean' }> | ArrayNode | ObjectNode;
+}
+
 export type ExpressionNode = BaseNode & {
   type: 'expression';
   operator: TokenOperator;
@@ -506,8 +514,8 @@ export class Parser {
         this.tokenizer.next(['whitespace', 'newline']);
         break;
       }
-      if (next.type === 'identifier') {
-        properties.push(this.parseAssignment(this.tokenizer.next(['whitespace', 'newline'])));
+      if (next.type === 'identifier' || next.type === 'string') {
+        properties.push(this.parseProperty(this.tokenizer.next(['whitespace', 'newline'])));
         next = this.tokenizer.peek(['whitespace', 'newline']);
         continue;
       }
@@ -526,6 +534,25 @@ export class Parser {
     return { type: 'object', properties, line: next.line, column: next.column, start: next.start, end: next.end };
   }
 
+  parseProperty(token: Token): PropertyNode {
+    if (token.type !== 'identifier' && token.type !== 'string') {
+      throw new Error(`Expected identifier or string but got ${token.type} at ${token.line}:${token.column}`);
+    }
+    const key = token;
+    const operator = this.expect('operator', '=');
+    const value = this.parseExpression();
+    return {
+      type: 'property',
+      operator,
+      key,
+      value,
+      line: key.line,
+      column: key.column,
+      start: key.start,
+      end: value.end,
+    };
+  }
+
   // Expect a token of a certain type, optionally with a certain
   // value.
   expect<T extends TokenType>(type: T, value?: string): Extract<Token, { type: T }> {
@@ -660,6 +687,30 @@ export class JSONTranslator {
             }
             return null;
           });
+        } else if (child.value.type === 'object') {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const objValue: { [key: string]: any } = {};
+          for (const prop of child.value.properties) {
+            if (prop.value.type === 'string') {
+              objValue[prop.key.value] = prop.value.value.slice(1, -1);
+            } else if (prop.value.type === 'number') {
+              objValue[prop.key.value] = parseFloat(prop.value.value);
+            } else if (prop.value.type === 'boolean') {
+              objValue[prop.key.value] = prop.value.value === 'true';
+            } else if (prop.value.type === 'array') {
+              objValue[prop.key.value] = prop.value.elements.map((el) => {
+                if (el.type === 'string') {
+                  return el.value.slice(1, -1);
+                } else if (el.type === 'number') {
+                  return parseFloat(el.value);
+                } else if (el.type === 'boolean') {
+                  return el.value === 'true';
+                }
+                return null;
+              });
+            }
+          }
+          obj[child.key.value] = objValue;
         }
       }
       if (child.type === 'stanza') {
@@ -704,6 +755,7 @@ export function fmt(ast: Node | Token | null, indent: number = 0, sibling?: Node
         }
       }
       break;
+    case 'property':
     case 'assignment':
       str += `${INDENT}${fmt(ast.key)} = ${fmt(ast.value)}`;
       break;

package/src/codestore.ts

@@ -112,7 +112,7 @@ export async function archive(bundle: ReadableBundle): Promise<ArrayBuffer> {
   for await (const file of bundle) {
     zip.file(file.name, await file.read());
   }
-  return await zip.generateAsync({ type: 'uint8array' });
+  return await zip.generateAsync({ type: 'arraybuffer' });
 }
 
 /**