@liquidmetal-ai/drizzle 0.0.1

package/dist/appify/parse.test.js

@@ -0,0 +1,319 @@
+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);
+});

package/dist/appify/validate.d.ts

@@ -0,0 +1,22 @@
+import { Actor, Application, Binding, Bucket, ConfigObject, Domain, Env, Observer, Queue, Service, SqlDatabase, VectorIndex } from './build.js';
+export type ValidationError = ConfigObject & {
+    message: string;
+    severity: 'info' | 'error' | 'warning';
+};
+export type On<T> = (app: Application, obj: T) => Promise<ValidationError[]>;
+export type Validator = {
+    onApplication?: On<Application>;
+    onService?: On<Service>;
+    onActor?: On<Actor>;
+    onObserver?: On<Observer>;
+    onBucket?: On<Bucket>;
+    onQueue?: On<Queue>;
+    onEnv?: On<Env>;
+    onBinding?: On<Binding>;
+    onDomain?: On<Domain>;
+    onSqlDatabase?: On<SqlDatabase>;
+    onVectorIndex?: On<VectorIndex>;
+};
+export declare function validate(apps: Application[], validators: Validator[]): Promise<ValidationError[]>;
+export declare const VALIDATORS: Validator[];
+//# sourceMappingURL=validate.d.ts.map

package/dist/appify/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/appify/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,WAAW,EACX,OAAO,EACP,MAAM,EACN,YAAY,EACZ,MAAM,EACN,GAAG,EACH,QAAQ,EACR,KAAK,EACL,OAAO,EACP,WAAW,EAEX,WAAW,EAEZ,MAAM,YAAY,CAAC;AAOpB,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;AAE7E,MAAM,MAAM,SAAS,GAAG;IACtB,aAAa,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC;IAChC,SAAS,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC;IACxB,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;IACpB,UAAU,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;IACpB,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;IAChB,SAAS,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;IACtB,aAAa,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC;IAChC,aAAa,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC;CACjC,CAAC;AAcF,wBAAsB,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAgBvG;AAiWD,eAAO,MAAM,UAAU,EAAE,SAAS,EAUjC,CAAC"}

package/dist/appify/validate.js

@@ -0,0 +1,346 @@
+import { valueOf, VISIBILITIES, } from './build.js';
+async function validateHelper(validatorFn, application, obj, errors) {
+    if (validatorFn) {
+        const returnedErrors = await validatorFn(application, obj);
+        errors.push(...returnedErrors);
+    }
+}
+export async function validate(apps, validators) {
+    const errors = [];
+    for (const app of apps) {
+        for (const validator of validators) {
+            await validateHelper(validator.onApplication, app, app, errors);
+            await validateServices(app, validator, errors);
+            await validateActors(app, validator, errors);
+            await validateObservers(app, validator, errors);
+            await validateBuckets(app, validator, errors);
+            await validateQueues(app, validator, errors);
+            await validateEnvs(app, app, validator, errors);
+            await validateVectorIndexes(app, validator, errors);
+            await validateSqlDatabases(app, validator, errors);
+        }
+    }
+    return errors;
+}
+async function validateServices(app, validator, errors) {
+    for (const service of app.service) {
+        await validateHelper(validator.onService, app, service, errors);
+        await validateBindings(app, service, validator, errors);
+        await validateDomains(app, service, validator, errors);
+        await validateEnvs(app, service, validator, errors);
+    }
+}
+async function validateActors(app, validator, errors) {
+    for (const actor of app.actor) {
+        await validateHelper(validator.onActor, app, actor, errors);
+        await validateBindings(app, actor, validator, errors);
+        await validateEnvs(app, actor, validator, errors);
+    }
+}
+async function validateObservers(app, validator, errors) {
+    for (const observer of app.observer) {
+        await validateHelper(validator.onObserver, app, observer, errors);
+        await validateBindings(app, observer, validator, errors);
+        await validateEnvs(app, observer, validator, errors);
+    }
+}
+async function validateBuckets(app, validator, errors) {
+    for (const bucket of app.bucket) {
+        await validateHelper(validator.onBucket, app, bucket, errors);
+    }
+}
+async function validateQueues(app, validator, errors) {
+    for (const queue of app.queue) {
+        await validateHelper(validator.onQueue, app, queue, errors);
+    }
+}
+async function validateVectorIndexes(app, validator, errors) {
+    for (const vectorIndex of app.vectorIndex) {
+        await validateHelper(validator.onVectorIndex, app, vectorIndex, errors);
+    }
+}
+async function validateSqlDatabases(app, validator, errors) {
+    for (const sqlDatabase of app.sqlDatabase) {
+        await validateHelper(validator.onSqlDatabase, app, sqlDatabase, errors);
+    }
+}
+async function validateEnvs(app, obj, validator, errors) {
+    for (const env of obj.env) {
+        await validateHelper(validator.onEnv, app, env, errors);
+    }
+}
+async function validateBindings(app, obj, validator, errors) {
+    for (const binding of obj.bindings) {
+        await validateHelper(validator.onBinding, app, binding, errors);
+    }
+}
+async function validateDomains(app, obj, validator, errors) {
+    for (const domain of obj.domains) {
+        await validateHelper(validator.onDomain, app, domain, errors);
+    }
+}
+// Validators
+const bindingNameValidator = {
+    onBinding: async (app, binding) => {
+        const errors = [];
+        for (const bind of binding.bindings) {
+            if (!bind.key.value.match(/^[A-Z][A-Z_]*$/)) {
+                errors.push({
+                    message: 'binding names should be UPPER_SNAKE_CASE',
+                    severity: 'warning',
+                    ...bind.key,
+                });
+            }
+        }
+        return errors;
+    },
+};
+const bindingValueValidator = {
+    onBinding: async (app, binding) => {
+        const errors = [];
+        for (const bind of binding.bindings) {
+            if (bind.value.type !== 'string') {
+                errors.push({
+                    message: 'bindings must be to names of modules',
+                    severity: 'error',
+                    ...bind.value,
+                });
+            }
+            else {
+                const ref = valueOf(bind.value);
+                // Walk the app to see if this is a module.
+                let all = [];
+                all = all.concat(app.bucket, app.env, app.observer, app.queue, app.service, app.sqlDatabase, app.vectorIndex);
+                if (!all.some((b) => valueOf(b.name) === ref)) {
+                    errors.push({
+                        message: `binding ${bind.value.value} not found`,
+                        severity: 'error',
+                        ...bind.value,
+                    });
+                }
+                else {
+                    // TODO [ian] It _is_ found, so let's make sure it's not
+                    // stomping on an implicit binding and check visibility
+                    // rules.
+                }
+            }
+        }
+        return errors;
+    },
+};
+const domainValidator = {
+    onDomain: async (app, domain) => {
+        const errors = [];
+        if (domain.fqdn === undefined) {
+            errors.push({
+                message: 'domain must have an fqdn',
+                severity: 'error',
+                ...domain.obj,
+            });
+        }
+        else if (!/^[a-z0-9]+([-.]{1}[a-z0-9]+)*\.[a-z]{2,6}$/.test(valueOf(domain.fqdn))) {
+            errors.push({
+                message: `domain ${domain.fqdn.value} is an invalid domain name`,
+                severity: 'warning',
+                ...domain.fqdn,
+            });
+        }
+        return errors;
+    },
+};
+const envValidator = {
+    onEnv: async (app, env) => {
+        const errors = [];
+        if (!valueOf(env.name).match(/^[A-Z][A-Z_]*$/)) {
+            errors.push({
+                message: 'env names should be UPPER_SNAKE_CASE',
+                severity: 'warning',
+                ...env.name,
+            });
+        }
+        if (env.secret?.value === 'true' && env.default !== undefined) {
+            errors.push({
+                message: 'secret env vars cannot have defaults',
+                severity: 'error',
+                ...env.default,
+            });
+        }
+        return errors;
+    },
+};
+const observerSourceValidator = {
+    onObserver: async (app, observer) => {
+        const errors = [];
+        const seen = new Set();
+        for (const source of observer.source) {
+            if (source.bucket && source.queue) {
+                errors.push({
+                    message: 'observer source can only have one of bucket or queue',
+                    severity: 'error',
+                    ...source.obj,
+                });
+            }
+            if (!source.bucket && !source.queue) {
+                errors.push({
+                    message: 'observer source must have either a bucket or a queue',
+                    severity: 'error',
+                    ...source.obj,
+                });
+            }
+            if (source.bucket !== undefined &&
+                !app.bucket.some((b) => valueOf(b.name) === (source.bucket && valueOf(source.bucket)))) {
+                errors.push({
+                    message: `bucket ${source.bucket.value} not found`,
+                    severity: 'error',
+                    ...source.bucket,
+                });
+            }
+            if (source.queue !== undefined &&
+                !app.queue.some((q) => valueOf(q.name) === (source.queue && valueOf(source.queue)))) {
+                errors.push({
+                    message: `queue ${source.queue.value} not found`,
+                    severity: 'error',
+                    ...source.queue,
+                });
+            }
+            const sourceName = (source.bucket && valueOf(source.bucket)) || (source.queue && valueOf(source.queue));
+            if (sourceName !== undefined) {
+                if (seen.has(sourceName)) {
+                    errors.push({
+                        message: `source ${sourceName} is duplicated`,
+                        severity: 'error',
+                        ...source.obj,
+                    });
+                }
+                seen.add(sourceName);
+            }
+            if (source.rule !== undefined && source.queue !== undefined) {
+                errors.push({
+                    message: 'queue sources do not have bucket notification rules',
+                    severity: 'error',
+                    ...source.obj,
+                });
+            }
+        }
+        return errors;
+    },
+};
+async function visibilityValidatorFn(app, obj) {
+    const errors = [];
+    if (obj.visibility && !VISIBILITIES.includes(valueOf(obj.visibility))) {
+        errors.push({
+            message: `visibility must be one of ${VISIBILITIES.join(', ')}`,
+            severity: 'error',
+            ...(obj.visibility || obj),
+        });
+    }
+    return errors;
+}
+const visibilityValidator = {
+    onService: visibilityValidatorFn,
+    onActor: visibilityValidatorFn,
+    onQueue: visibilityValidatorFn,
+    onBucket: visibilityValidatorFn,
+};
+async function nameValidatorFn(app, obj) {
+    const errors = [];
+    if (!valueOf(obj.name).match(/^[a-z][a-z0-9-]*$/)) {
+        errors.push({
+            message: `name must be lowercase and dash-separated`,
+            severity: 'error',
+            ...obj.name,
+        });
+    }
+    return errors;
+}
+const nameValidator = {
+    onApplication: nameValidatorFn,
+    onService: nameValidatorFn,
+    onObserver: nameValidatorFn,
+    onBucket: nameValidatorFn,
+    onQueue: nameValidatorFn,
+    onActor: nameValidatorFn,
+    onSqlDatabase: nameValidatorFn,
+    onVectorIndex: nameValidatorFn,
+};
+const vectorIndexValidator = {
+    onVectorIndex: async (app, vectorIndex) => {
+        const errors = [];
+        if (vectorIndex.dimension === undefined) {
+            errors.push({
+                message: 'vector index must have a dimension',
+                severity: 'error',
+                ...vectorIndex.obj,
+            });
+        }
+        if (vectorIndex.metric === undefined ||
+            (valueOf(vectorIndex.metric) !== 'cosine' && valueOf(vectorIndex.metric) !== 'euclidean')) {
+            errors.push({
+                message: 'vector index metric must be either cosine or euclidean',
+                severity: 'error',
+                ...(vectorIndex.metric || vectorIndex.obj),
+            });
+        }
+        if (errors.length > 0) {
+            return errors;
+        }
+        // We have to re-check because the above is too complex for TS.
+        if (vectorIndex.dimension === undefined) {
+            return errors;
+        }
+        const dimension = valueOf(vectorIndex.dimension);
+        if (!Number.isInteger(dimension)) {
+            errors.push({
+                message: 'vector index dimension must be an integer',
+                severity: 'error',
+                ...vectorIndex.dimension,
+            });
+            return errors;
+        }
+        if (dimension < 1 || dimension > 1536) {
+            errors.push({
+                message: 'vector index dimension must be between 1 and 1536',
+                severity: 'error',
+                ...vectorIndex.dimension,
+            });
+        }
+        return errors;
+    },
+};
+const duplicateModuleValidator = {
+    onApplication: async (app, _application) => {
+        const errors = [];
+        const seen = new Set();
+        for (const module of [
+            ...app.bucket,
+            ...app.env,
+            ...app.observer,
+            ...app.queue,
+            ...app.service,
+            ...app.sqlDatabase,
+            ...app.vectorIndex,
+        ]) {
+            const name = valueOf(module.name);
+            if (seen.has(name)) {
+                errors.push({
+                    message: `module ${name} has already been defined`,
+                    severity: 'error',
+                    ...module.name,
+                });
+            }
+            seen.add(name);
+        }
+        return errors;
+    },
+};
+export const VALIDATORS = [
+    bindingNameValidator,
+    bindingValueValidator,
+    domainValidator,
+    envValidator,
+    observerSourceValidator,
+    visibilityValidator,
+    nameValidator,
+    vectorIndexValidator,
+    duplicateModuleValidator,
+];

package/dist/appify/validate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validate.test.d.ts.map

package/dist/appify/validate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.test.d.ts","sourceRoot":"","sources":["../../src/appify/validate.test.ts"],"names":[],"mappings":""}