@liquidmetal-ai/drizzle 0.1.3 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liquidmetal-ai/drizzle",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Raindrop core operational libraries",
   "main": "dist/index.js",
   "type": "module",

package/src/appify/build.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from 'vitest';
-import { buildManifest } from './build.js';
+import { buildManifest, valueOf } from './build.js';
 import { Parser, Tokenizer } from './parse.js';
 
 const CONFIG = `
@@ -9,7 +9,7 @@ application "my-app" {
   service "my-service" {
     route {
       zone = "testymctestface.com"
-      pattern = "testymctestface.com/*"
+      domain = "testymctestface.com"
     }
 
     domain {
@@ -36,6 +36,10 @@ application "my-app" {
     visibility = 'public'
   }
 
+  smartbucket "my-smart-bucket" {
+    location_hint = "enam"
+  }
+
   observer "my-observer" {
     env "API_KEY" {}
     source {
@@ -63,9 +67,15 @@ application "my-app" {
   sql_database "my-database" {}
 
   vector_index "my-index" {
-    dimension = 768
+    dimensions = 768
     metric = 'cosine'
   }
+
+  task "my-task" {
+    type = "cron"
+    cron = "* * * * *"
+    visibility = 'protected'
+  }
 }
 `;
 
@@ -112,3 +122,75 @@ application "foo" {
     },
   ]);
 });
+
+test('smartbucket parsing', () => {
+  const CONFIG = `
+application "my-app" {
+  smartbucket "my-smart-bucket" {
+    location_hint = "enam"
+  }
+}
+`;
+  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
+  expect(apps.length).toBe(1);
+
+  // Check that we have exactly one smartbucket
+  expect(apps[0]!.smartBucket.length).toBe(1);
+
+  // Check the smartbucket properties
+  const smartBucket = apps[0]!.smartBucket[0]!;
+  expect(valueOf(smartBucket.name)).toBe("my-smart-bucket");
+  expect(smartBucket.locationHint).toBeDefined();
+  expect(valueOf(smartBucket.locationHint!)).toBe("enam");
+});
+
+test('smartbucket with invalid properties', () => {
+  const CONFIG = `
+application "my-app" {
+  smartbucket "my-smart-bucket" {
+    location_hint = "enam"
+    invalid_property = "should fail"
+  }
+}
+`;
+  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 property
+  expect(errors.length).toBe(1);
+  expect(errors[0]!.message).toContain('unexpected assignment');
+});
+
+test('smartbucket with duplicate assignment', () => {
+  const CONFIG = `
+application "foo" {
+  smartbucket "my-smart-bucket" {
+    location_hint = "enam"
+    location_hint = "other-location"
+  }
+}
+`;
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+
+  const [, errors] = buildManifest(ast);
+  expect(errors).toMatchObject([
+    {
+      message: 'duplicate location_hint assignment "other-location"',
+    },
+  ]);
+});

package/src/appify/build.ts

@@ -25,7 +25,7 @@ export function valueOf(token: TokenString | TokenNumber | TokenBoolean): string
   if (token.type === 'string') {
     return token.value.slice(1, -1);
   }
-  throw new Error(`unexpected token type`);
+  throw new Error(`unexpected token type: ${token}`);
 }
 
 export interface ConfigObject {
@@ -161,6 +161,9 @@ export function buildApplication(node: StanzaNode): [Application | undefined, Co
           case 'actor':
             buildStanza(buildActor, child, app.actor, errors);
             break;
+          case 'task':
+            buildStanza(buildTask, child, app.task, errors);
+            break;
           case 'bucket':
             buildStanza(buildBucket, child, app.bucket, errors);
             break;
@@ -173,8 +176,14 @@ export function buildApplication(node: StanzaNode): [Application | undefined, Co
           case 'sql_database':
             buildStanza(buildSqlDatabase, child, app.sqlDatabase, errors);
             break;
+          case 'kv_store':
+            buildStanza(buildKvStore, child, app.kvStore, errors);
+            break;
+          case 'smartbucket':
+            buildStanza(buildSmartBucket, child, app.smartBucket, errors);
+            break;
           default:
-            errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+            errors.push({ message: 'unexpected stanza', ...child });
         }
         break;
       case 'assignment':
@@ -215,7 +224,7 @@ function buildService(stanza: StanzaNode): [Service, ConfigError[]] {
             buildStanza(buildEnv, child, service.env, errors);
             break;
           default:
-            errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+            errors.push({ message: 'unexpected stanza', ...child });
         }
         break;
       case 'assignment':
@@ -245,13 +254,16 @@ function buildBucket(stanza: StanzaNode): [Bucket, ConfigError[]] {
   for (const child of stanza.block?.children ?? []) {
     switch (child.type) {
       case 'stanza':
-        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        errors.push({ message: 'unexpected stanza', ...child });
         break;
       case 'assignment':
         switch (child.key.value) {
           case 'visibility':
             buildAssignment(bucket, 'visibility', 'string', child, errors);
             break;
+          case 'location_hint':
+            buildAssignment(bucket, 'locationHint', 'string', child, errors);
+            break;
           default:
             errors.push({ message: 'unexpected assignment', ...child });
         }
@@ -274,7 +286,7 @@ function buildQueue(stanza: StanzaNode): [Queue, ConfigError[]] {
   for (const child of stanza.block?.children ?? []) {
     switch (child.type) {
       case 'stanza':
-        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        errors.push({ message: 'unexpected stanza', ...child });
         break;
       case 'assignment':
         switch (child.key.value) {
@@ -303,7 +315,7 @@ function buildVectorIndex(stanza: StanzaNode): [Bucket, ConfigError[]] {
   for (const child of stanza.block?.children ?? []) {
     switch (child.type) {
       case 'stanza':
-        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        errors.push({ message: 'unexpected stanza', ...child });
         break;
       case 'assignment':
         switch (child.key.value) {
@@ -338,7 +350,7 @@ function buildSqlDatabase(stanza: StanzaNode): [SqlDatabase, ConfigError[]] {
   for (const child of stanza.block?.children ?? []) {
     switch (child.type) {
       case 'stanza':
-        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        errors.push({ message: 'unexpected stanza', ...child });
         break;
       case 'assignment':
         switch (child.key.value) {
@@ -359,6 +371,62 @@ function buildSqlDatabase(stanza: StanzaNode): [SqlDatabase, ConfigError[]] {
   return [sqlDatabase, errors];
 }
 
+function buildKvStore(stanza: StanzaNode): [KvStore, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const kvStore = new KvStore(name, stanza);
+
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case 'stanza':
+        errors.push({ message: 'unexpected stanza', ...child });
+        break;
+      case 'assignment':
+        switch (child.key.value) {
+          case 'visibility':
+            buildAssignment(kvStore, '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 [kvStore, errors];
+}
+
+function buildSmartBucket(stanza: StanzaNode): [SmartBucket, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const smartBucket = new SmartBucket(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case 'assignment':
+        switch (child.key.value) {
+          case 'location_hint':
+            buildAssignment(smartBucket, 'locationHint', '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 [smartBucket, errors];
+}
+
 function buildObserver(stanza: StanzaNode): [Observer, ConfigError[]] {
   const errors: ConfigError[] = [];
   const [name, nameErrors] = buildName1(stanza);
@@ -380,7 +448,7 @@ function buildObserver(stanza: StanzaNode): [Observer, ConfigError[]] {
             buildStanza(buildEnv, child, observer.env, errors);
             break;
           default:
-            errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+            errors.push({ message: 'unexpected stanza', ...child });
         }
         break;
       case 'assignment':
@@ -414,7 +482,7 @@ function buildActor(stanza: StanzaNode): [Actor, ConfigError[]] {
             buildStanza(buildEnv, child, actor.env, errors);
             break;
           default:
-            errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+            errors.push({ message: 'unexpected stanza', ...child });
         }
         break;
       case 'assignment':
@@ -437,6 +505,48 @@ function buildActor(stanza: StanzaNode): [Actor, ConfigError[]] {
   return [actor, errors];
 }
 
+function buildTask(stanza: StanzaNode): [Task, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName1(stanza);
+  errors.push(...nameErrors);
+  const task = new Task(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, task.bindings, errors);
+            break;
+          case 'env':
+            buildStanza(buildEnv, child, task.env, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected stanza', ...child });
+        }
+        break;
+      case 'assignment':
+        switch (child.key.value) {
+          case 'type':
+            buildAssignment(task, 'type', 'string', child, errors);
+            break;
+          case 'cron':
+            buildAssignment(task, 'cron', 'string', child, errors);
+            break;
+          case 'visibility':
+            buildAssignment(task, 'visibility', 'string', child, errors);
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
+        break;
+    }
+  }
+
+  return [task, errors];
+}
+
 function buildSource(stanza: StanzaNode): [Source, ConfigError[]] {
   const errors: ConfigError[] = [];
   const source = new Source(stanza);
@@ -486,13 +596,13 @@ function buildSource(stanza: StanzaNode): [Source, ConfigError[]] {
                 buildAssignment(rule, 'suffix', 'string', ruleChild, errors);
                 break;
               default:
-                errors.push({ message: `unexpected assignment ${ruleChild.key}`, ...ruleChild });
+                errors.push({ message: 'unexpected assignment', ...ruleChild });
             }
           }
         }
         source.rule.push(rule);
       } else {
-        errors.push({ message: `unexpected stanza ${child.name}`, ...child });
+        errors.push({ message: 'unexpected stanza', ...child });
       }
     }
   }
@@ -508,26 +618,26 @@ function buildRoute(stanza: StanzaNode): [Route | undefined, ConfigError[]] {
   for (const child of stanza.block?.children ?? []) {
     if (child.type === 'assignment') {
       switch (child.key.value) {
+        case 'cname':
+          buildAssignment(route, 'cname', 'string', child, errors);
+          break;
+        case 'domain':
+          buildAssignment(route, 'domain', 'string', child, errors);
+          break;
+        case 'path':
+          buildAssignment(route, 'path', 'string', child, errors);
+          break;
         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];
+  if (route.cname && route.domain) {
+    errors.push({ message: 'cname cannot be used with domain', ...stanza });
   }
-  // TODO [ian]: validate zone and pattern contents.
   return [route, errors];
 }
 
@@ -605,11 +715,14 @@ export class Application {
   service: Service[] = [];
   observer: Observer[] = [];
   actor: Actor[] = [];
+  task: Task[] = [];
   bucket: Bucket[] = [];
   queue: Queue[] = [];
   env: Env[] = [];
   sqlDatabase: SqlDatabase[] = [];
   vectorIndex: VectorIndex[] = [];
+  kvStore: KvStore[] = [];
+  smartBucket: SmartBucket[] = [];
 
   constructor(name: TokenString, obj: ConfigObject) {
     this.name = name;
@@ -617,8 +730,8 @@ export class Application {
   }
 
   // Return all objects that require code handlers.
-  handlers(): (Service | Observer | Actor)[] {
-    return [...this.service, ...this.observer, ...this.actor];
+  handlers(): (Service | Observer | Actor | Task)[] {
+    return [...this.service, ...this.observer, ...this.actor, ...this.task];
   }
 }
 
@@ -650,6 +763,21 @@ export class Actor {
   }
 }
 
+export class Task {
+  obj: ConfigObject;
+  name: TokenString;
+  type?: TokenString;
+  cron?: 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;
@@ -694,7 +822,9 @@ export class Rule {
 export class Route {
   obj: ConfigObject;
   zone?: TokenString;
-  pattern?: TokenString;
+  domain?: TokenString;
+  cname?: TokenString;
+  path?: TokenString;
 
   constructor(obj: ConfigObject) {
     this.obj = obj;
@@ -734,6 +864,18 @@ export class Env {
 }
 
 export class Bucket {
+  name: TokenString;
+  visibility?: TokenString;
+  locationHint?: TokenString;
+  obj: ConfigObject;
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export class KvStore {
   name: TokenString;
   visibility?: TokenString;
   obj: ConfigObject;
@@ -780,5 +922,19 @@ export class SqlDatabase {
   }
 }
 
+export class SmartBucket {
+  name: TokenString;
+  locationHint?: 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];
+
+export const TASK_TYPES = ['cron'] as const;
+export type TaskType = (typeof TASK_TYPES)[number];

package/src/appify/validate.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from 'vitest';
+import { expect, test, describe, it } from 'vitest';
 import { buildManifest } from './build.js';
 import { Parser, Tokenizer } from './parse.js';
 import { validate, VALIDATORS } from './validate.js';
@@ -11,6 +11,10 @@ application "my-app" {
   observer "my-observer" {}
   bucket "my-bucket" {}
   queue "my-queue" {}
+  task "my-cron" {
+    type = "cron"
+    cron = "* * * * *"
+  }
 }
 `;
   const tokenizer = new Tokenizer(manifest);
@@ -280,7 +284,7 @@ application "my-app" {
   const validateErrors = await validate(builtApps, VALIDATORS);
   expect(validateErrors).toMatchObject([
     {
-      message: 'vector index must have a dimension',
+      message: 'vector index must have a dimensions',
     },
     {
       message: 'vector index metric must be either cosine or euclidean',
@@ -293,7 +297,7 @@ test('validate vector index parameters', async () => {
 application "my-app" {
   service "my-service" {}
   vector_index "my-index" {
-    dimension = 128.9
+    dimensions = 128.9
     metric = "cosine"
   }
 }
@@ -305,7 +309,7 @@ application "my-app" {
   const validateErrors = await validate(builtApps, VALIDATORS);
   expect(validateErrors).toMatchObject([
     {
-      message: 'vector index dimension must be an integer',
+      message: 'vector index dimensions must be an integer',
     },
   ]);
 });
@@ -433,3 +437,72 @@ application "my-app" {
     },
   ]);
 });
+
+describe('task validator', async () => {
+  it('validates task types', async () => {
+    const manifest = `
+    application "my-app" {
+      task "my-task" {
+        type = "thingie" // not a valid task type
+      }
+    }
+    `;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([
+      {
+        message: 'task type must be one of: cron',
+      },
+    ]);
+  });
+
+  it('validates task cron expressions', async () => {
+    const manifest = `
+    application "my-app" {
+      task "my-task" {
+        type = "cron"
+        cron = "* * * * */30"
+      }
+    }
+    `;
+    const tokenizer = new Tokenizer(manifest);
+    const parser = new Parser(tokenizer);
+    const parsedManifest = parser.parse();
+    const [builtApps] = buildManifest(parsedManifest);
+    const validateErrors = await validate(builtApps, VALIDATORS);
+    expect(validateErrors).toMatchObject([]);
+  });
+
+  it('invalidates task cron expressions', async () => {
+    const invalidManifests = [
+      `
+      application "my-app" {
+        task "my-task" {
+          type = "cron"
+          cron = "* * * *"  // invalid, should have 5 parts
+        }
+      }
+      `,
+      `
+      application "my-app" {
+        task "my-task" {
+          type = "cron"
+          cron = "* * * * x"  // invalid last part
+        }
+      }
+      `,
+    ];
+    for (const manifest of invalidManifests) {
+      const tokenizer = new Tokenizer(manifest);
+      const parser = new Parser(tokenizer);
+      const parsedManifest = parser.parse();
+      const [builtApps] = buildManifest(parsedManifest);
+      const validateErrors = await validate(builtApps, VALIDATORS);
+      expect(validateErrors.length).toBe(1);
+      expect(validateErrors[0]?.message).toContain('task cron expression is malformed');
+    }
+  });
+});