@liquidmetal-ai/drizzle 0.0.1

package/src/appify/index.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from 'vitest';
+import { valueOf } from './build.js';
+import { ManifestError, mustManifestFromString } from './index.js';
+
+test('mustManifestFromString no errors', async () => {
+  const manifest = `
+application "app" {
+  service "svc" {}
+}
+`;
+  const apps = await mustManifestFromString(manifest);
+  expect(apps).toHaveLength(1);
+  expect(valueOf(apps[0]!.name)).toBe('app');
+  expect(apps[0]!.service).toHaveLength(1);
+  expect(valueOf(apps[0]!.service[0]!.name)).toBe('svc');
+});
+
+test('mustManifestFromString with errors', async () => {
+  const manifest = `
+application "app" {
+  service "my-svc" {}
+  service "my-svc" {}
+}
+`;
+  expect(mustManifestFromString(manifest)).rejects.toThrowError(ManifestError);
+});
+
+test('mustManifestFromString with warnings', async () => {
+  const manifest = `
+application "app" {
+  service "svc" {
+    domain {
+      fqdn = "bad_domain_name"
+    }
+  }
+}
+`;
+  const apps = await mustManifestFromString(manifest);
+  expect(apps).toHaveLength(1);
+  expect(valueOf(apps[0]!.name)).toBe('app');
+  expect(apps[0]!.service).toHaveLength(1);
+  expect(valueOf(apps[0]!.service[0]!.name)).toBe('svc');
+});

package/src/appify/index.ts

@@ -0,0 +1,33 @@
+import { Application, buildManifest, ConfigError } from '@liquidmetal-ai/drizzle/appify/build';
+import { Parser, Tokenizer } from '@liquidmetal-ai/drizzle/appify/parse';
+import { validate, VALIDATORS } from '@liquidmetal-ai/drizzle/appify/validate';
+
+export class ManifestError extends Error {
+  errors: ConfigError[];
+
+  constructor(errors: ConfigError[]) {
+    const message = errors.map((e) => `${e.line}:${e.column} - ${e.message}`).join('\n');
+    super(message);
+    this.errors = errors;
+  }
+}
+
+export async function manifestFromString(manifestString: string): Promise<[Application[], ConfigError[]]> {
+  const tokenizer = new Tokenizer(manifestString);
+  const parser = new Parser(tokenizer);
+  const ast = parser.parse();
+  const parseErrors = parser.errors;
+  const [apps, buildErrors] = buildManifest(ast);
+  const validationErrors = await validate(apps, VALIDATORS);
+
+  return [apps, [...parseErrors, ...buildErrors, ...validationErrors]];
+}
+
+// MUST load without errors, but ignores warnings.
+export async function mustManifestFromString(manifestString: string): Promise<Application[]> {
+  const [apps, errors] = await manifestFromString(manifestString);
+  if (errors.length > 0 && !errors.every((e) => 'severity' in e && e.severity === 'warning')) {
+    throw new ManifestError(errors);
+  }
+  return apps;
+}

package/src/appify/parse.test.ts

@@ -0,0 +1,337 @@
+import { expect, test } from 'vitest';
+import { JSONTranslator, Parser, Tokenizer, fmt } from './parse.js';
+
+const CONFIG = `
+application "my-app" {
+service "my-service" {
+domain {
+fqdn = "testymctestface.com"
+}
+
+binding {
+// This is a binding of foo to "bar".
+foo = "bar" // this is a comment
+}
+
+  // comment
+env "API_KEY" {
+secret = true
+}
+
+env "API_URL" {
+ // Empty but has a comment.
+}
+env  "API_PATH" {
+}
+}
+observer "my-observer" {
+source {
+bucket = "my-bucket"
+rule {
+actions = ['PutObject', 'DeleteObject']
+}
+}
+}
+}
+}
+}
+`;
+
+const CONFIG_FORMATTED = `
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+
+    binding {
+      // This is a binding of foo to "bar".
+      foo = "bar"  // this is a comment
+    }
+
+    // comment
+    env "API_KEY" {
+      secret = true
+    }
+
+    env "API_URL" {
+      // Empty but has a comment.
+    }
+    env "API_PATH" {}
+  }
+  observer "my-observer" {
+    source {
+      bucket = "my-bucket"
+      rule {
+        actions = ['PutObject', 'DeleteObject']
+      }
+    }
+  }
+}
+`;
+
+test('parser', () => {
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const translator = new JSONTranslator();
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+  expect(translator.translate(ast)).toEqual({
+    application: [
+      {
+        name: 'my-app',
+        observer: [
+          {
+            name: 'my-observer',
+            source: [
+              {
+                bucket: 'my-bucket',
+                rule: [
+                  {
+                    actions: ['PutObject', 'DeleteObject'],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+        service: [
+          {
+            name: 'my-service',
+            domain: [
+              {
+                fqdn: 'testymctestface.com',
+              },
+            ],
+            binding: [
+              {
+                foo: 'bar',
+              },
+            ],
+            env: [
+              {
+                name: 'API_KEY',
+                secret: true,
+              },
+              {
+                name: 'API_URL',
+              },
+              {
+                name: 'API_PATH',
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  });
+});
+
+test('fmt', () => {
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const ast = parser.parse();
+  expect(fmt(ast)).toEqual(CONFIG_FORMATTED);
+});
+
+test('parser errors', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" }
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(1);
+
+  const tokenizer2 = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+  }
+`);
+  const parser2 = new Parser(tokenizer2);
+  parser2.parse();
+  expect(parser2.errors).toHaveLength(1);
+});
+
+test('wrong curly brace', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+  {
+}
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(2);
+});
+
+test('root parse runs into something unexpected', () => {
+  const tokenizer = new Tokenizer(` "foo" `);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(1);
+});
+
+test('empty is valid (just borring)', () => {
+  const tokenizer = new Tokenizer(` `);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(0);
+});
+
+test('identifier followed by not {, string, number, boolean, operator', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+    foo
+  }
+}
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(1);
+});
+
+test("stanza doesn't have string, number, boolean arguments", () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" indentifier {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+  }
+}
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(1);
+});
+
+test('unexpected newline in expression', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+    foo =
+  }
+}
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(1);
+});
+
+test('unexpected trash in an array', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+    foo = [1, 2, 3, } ]
+  }
+}
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(1);
+});
+
+test('unclosed array', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+    foo = [1, 2, 3, }
+  }
+}
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(2); // unexpecte curly and expected ]
+});
+
+test('parse object', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+    foo = {
+      bar = "baz"
+    }
+  }
+}
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  console.log(parser.errors);
+  expect(parser.errors).toHaveLength(0);
+});
+
+test('parse object with trash', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+    foo = {
+      bar = "baz"
+      baz
+    }
+  }
+}
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(2); // missing = and expression
+});
+
+test('parse object with more trash', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+    foo = {
+      bar = "baz"
+      true = false
+    }
+  }
+}
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  expect(parser.errors).toHaveLength(3);
+});
+
+test('parse object that EOFs', () => {
+  const tokenizer = new Tokenizer(`
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "testymctestface.com"
+    }
+    foo = {
+      bar = "baz"
+`);
+  const parser = new Parser(tokenizer);
+  parser.parse();
+  // Failed to close 3 curly braces.
+  expect(parser.errors).toHaveLength(3);
+});