@liquidmetal-ai/drizzle 0.1.3 → 0.2.2

package/dist/appify/validate.js

@@ -1,4 +1,4 @@
-import { valueOf, VISIBILITIES, } from './build.js';
+import { TASK_TYPES, valueOf, VISIBILITIES, } from './build.js';
 async function validateHelper(validatorFn, application, obj, errors) {
     if (validatorFn) {
         const returnedErrors = await validatorFn(application, obj);
@@ -13,6 +13,7 @@ export async function validate(apps, validators) {
             await validateServices(app, validator, errors);
             await validateActors(app, validator, errors);
             await validateObservers(app, validator, errors);
+            await validateTasks(app, validator, errors);
             await validateBuckets(app, validator, errors);
             await validateQueues(app, validator, errors);
             await validateEnvs(app, app, validator, errors);
@@ -44,6 +45,13 @@ async function validateObservers(app, validator, errors) {
         await validateEnvs(app, observer, validator, errors);
     }
 }
+async function validateTasks(app, validator, errors) {
+    for (const task of app.task) {
+        await validateHelper(validator.onTask, app, task, errors);
+        await validateBindings(app, task, validator, errors);
+        await validateEnvs(app, task, validator, errors);
+    }
+}
 async function validateBuckets(app, validator, errors) {
     for (const bucket of app.bucket) {
         await validateHelper(validator.onBucket, app, bucket, errors);
@@ -252,6 +260,45 @@ const observerSourceValidator = {
         return errors;
     },
 };
+const taskValidator = {
+    onTask: async (app, task) => {
+        const errors = [];
+        if (task.type === undefined) {
+            errors.push({
+                message: 'task must have a type',
+                severity: 'error',
+                ...task.obj,
+            });
+            return errors;
+        }
+        if (TASK_TYPES.indexOf(valueOf(task.type)) === -1) {
+            errors.push({
+                message: `task type must be one of: ${TASK_TYPES.join(', ')}`,
+                severity: 'error',
+                ...task.obj,
+            });
+            return errors;
+        }
+        if (valueOf(task.type) === 'cron') {
+            if (task.cron === undefined) {
+                errors.push({
+                    message: 'cron task must have a cron attribute',
+                    severity: 'error',
+                    ...task.obj,
+                });
+            }
+            else if (!VALID_CRON_PATTERN.test(valueOf(task.cron))) {
+                errors.push({
+                    message: `task cron expression is malformed: ${valueOf(task.cron)}`,
+                    severity: 'error',
+                    ...task.obj,
+                });
+            }
+        }
+        return errors;
+    },
+};
+const VALID_CRON_PATTERN = /(@(annually|yearly|monthly|weekly|daily|hourly|reboot))|(@every (\d+(ns|us|µs|ms|s|m|h))+)|((((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*) ?){5,7})/;
 async function visibilityValidatorFn(app, obj) {
     const errors = [];
     if (obj.visibility && !VISIBILITIES.includes(valueOf(obj.visibility))) {
@@ -266,6 +313,7 @@ async function visibilityValidatorFn(app, obj) {
 const visibilityValidator = {
     onService: visibilityValidatorFn,
     onActor: visibilityValidatorFn,
+    onTask: visibilityValidatorFn,
     onQueue: visibilityValidatorFn,
     onBucket: visibilityValidatorFn,
 };
@@ -306,7 +354,7 @@ const vectorIndexValidator = {
         const errors = [];
         if (vectorIndex.dimensions === undefined) {
             errors.push({
-                message: 'vector index must have a dimension',
+                message: 'vector index must have a dimensions',
                 severity: 'error',
                 ...vectorIndex.obj,
             });
@@ -371,14 +419,35 @@ const duplicateModuleValidator = {
         return errors;
     },
 };
+const locationHintValidator = {
+    onBucket: async (app, bucket) => {
+        const locations = ['wnam', 'enam', 'weur', 'eeur', 'apac', 'oc'];
+        const errors = [];
+        // Default value is enam.
+        if (bucket.locationHint === undefined) {
+            return errors;
+        }
+        // Check if the value is valid.
+        if (!locations.includes(valueOf(bucket.locationHint))) {
+            errors.push({
+                message: `location_hint must be one of ${locations.join(', ')}`,
+                severity: 'error',
+                ...bucket.locationHint,
+            });
+        }
+        return errors;
+    },
+};
 export const VALIDATORS = [
     bindingNameValidator,
     bindingValueValidator,
     domainValidator,
     envValidator,
     observerSourceValidator,
+    taskValidator,
     visibilityValidator,
     nameValidator,
     vectorIndexValidator,
     duplicateModuleValidator,
+    locationHintValidator,
 ];

package/dist/appify/validate.test.js

@@ -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';
@@ -10,6 +10,10 @@ application "my-app" {
   observer "my-observer" {}
   bucket "my-bucket" {}
   queue "my-queue" {}
+  task "my-cron" {
+    type = "cron"
+    cron = "* * * * *"
+  }
 }
 `;
     const tokenizer = new Tokenizer(manifest);
@@ -268,7 +272,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',
@@ -280,7 +284,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"
   }
 }
@@ -292,7 +296,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',
         },
     ]);
 });
@@ -415,3 +419,69 @@ 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');
+        }
+    });
+});

package/dist/codestore.js

@@ -50,7 +50,7 @@ export async function archive(bundle) {
     for await (const file of bundle) {
         zip.file(file.name, await file.read());
     }
-    return await zip.generateAsync({ type: 'arraybuffer' });
+    return await zip.generateAsync({ type: 'uint8array' });
 }
 /**
  * Extracts files from a ZIP archive into a writable bundle
@@ -63,7 +63,7 @@ export async function unarchive(zipBuffer, bundle) {
         if (file.dir) {
             continue;
         }
-        const content = await file.async('arraybuffer');
+        const content = await file.async('uint8array');
         await bundle.write(file.name, Buffer.from(content));
     }
 }

package/dist/liquidmetal/v1alpha1/catalog_connect.d.ts

@@ -1,4 +1,4 @@
-import { ApplicationsRequest, ApplicationsResponse, BootstrapRequest, BootstrapResponse, CreateApplicationsRequest, CreateApplicationsResponse, CreateVersionRequest, CreateVersionResponse, DeleteApplicationsRequest, DeleteApplicationsResponse, GetEnvRequest, GetEnvResponse, QueryResourcesRequest, QueryResourcesResponse, SetApplicationActiveStatesRequest, SetApplicationActiveStatesResponse, SetApplicationManifestsRequest, SetApplicationManifestsResponse, SetEnvRequest, SetEnvResponse, SetVersionSandboxStatesRequest, SetVersionSandboxStatesResponse, StatBundleRequest, StatBundleResponse, UploadBundleRequest, UploadBundleResponse, VersionsRequest, VersionsResponse } from "./catalog_pb.js";
+import { ApplicationsRequest, ApplicationsResponse, BootstrapRequest, BootstrapResponse, DeleteRequest, DeleteResponse, DeployRequest, DeployResponse, GetEnvsRequest, GetEnvsResponse, QueryResourcesRequest, QueryResourcesResponse, ReleaseRequest, ReleaseResponse, SetActiveRequest, SetActiveResponse, SetEnvsRequest, SetEnvsResponse, SetSandboxRequest, SetSandboxResponse, StatusRequest, StatusResponse, UploadBundleRequest, UploadBundleResponse, WatchRequest, WatchResponse } from "./catalog_pb.js";
 import { MethodKind } from "@bufbuild/protobuf";
 /**
  * CatalogService defines data interactions for the catalog portion of the
@@ -17,6 +17,17 @@ import { MethodKind } from "@bufbuild/protobuf";
 export declare const CatalogService: {
     readonly typeName: "liquidmetal.v1alpha1.CatalogService";
     readonly methods: {
+        /**
+         * QueryResources returns the physical underlying resources for a given query
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.QueryResources
+         */
+        readonly queryResources: {
+            readonly name: "QueryResources";
+            readonly I: typeof QueryResourcesRequest;
+            readonly O: typeof QueryResourcesResponse;
+            readonly kind: MethodKind.Unary;
+        };
         /**
          * Bootstrap is a special RPC that is used to bootstrap the system
          * using a one-time token.
@@ -29,33 +40,6 @@ export declare const CatalogService: {
             readonly O: typeof BootstrapResponse;
             readonly kind: MethodKind.Unary;
         };
-        /**
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.Versions
-         */
-        readonly versions: {
-            readonly name: "Versions";
-            readonly I: typeof VersionsRequest;
-            readonly O: typeof VersionsResponse;
-            readonly kind: MethodKind.Unary;
-        };
-        /**
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.CreateVersion
-         */
-        readonly createVersion: {
-            readonly name: "CreateVersion";
-            readonly I: typeof CreateVersionRequest;
-            readonly O: typeof CreateVersionResponse;
-            readonly kind: MethodKind.Unary;
-        };
-        /**
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.SetVersionSandboxStates
-         */
-        readonly setVersionSandboxStates: {
-            readonly name: "SetVersionSandboxStates";
-            readonly I: typeof SetVersionSandboxStatesRequest;
-            readonly O: typeof SetVersionSandboxStatesResponse;
-            readonly kind: MethodKind.Unary;
-        };
         /**
          * Applications fetches a list of applications for an organization.
          * This list follows best practices for pagination.
@@ -70,94 +54,113 @@ export declare const CatalogService: {
             readonly kind: MethodKind.Unary;
         };
         /**
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.CreateApplications
+         * Deploy creates a new version, or branch, or amends in place.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.Deploy
          */
-        readonly createApplications: {
-            readonly name: "CreateApplications";
-            readonly I: typeof CreateApplicationsRequest;
-            readonly O: typeof CreateApplicationsResponse;
+        readonly deploy: {
+            readonly name: "Deploy";
+            readonly I: typeof DeployRequest;
+            readonly O: typeof DeployResponse;
             readonly kind: MethodKind.Unary;
         };
         /**
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.SetApplicationActiveStates
+         * UploadBundle uploads a bundle for a specific application version.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.UploadBundle
          */
-        readonly setApplicationActiveStates: {
-            readonly name: "SetApplicationActiveStates";
-            readonly I: typeof SetApplicationActiveStatesRequest;
-            readonly O: typeof SetApplicationActiveStatesResponse;
+        readonly uploadBundle: {
+            readonly name: "UploadBundle";
+            readonly I: typeof UploadBundleRequest;
+            readonly O: typeof UploadBundleResponse;
             readonly kind: MethodKind.Unary;
         };
         /**
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.DeleteApplications
+         * SetEnvs sets multiple environment variables for an application/version.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.SetEnvs
          */
-        readonly deleteApplications: {
-            readonly name: "DeleteApplications";
-            readonly I: typeof DeleteApplicationsRequest;
-            readonly O: typeof DeleteApplicationsResponse;
+        readonly setEnvs: {
+            readonly name: "SetEnvs";
+            readonly I: typeof SetEnvsRequest;
+            readonly O: typeof SetEnvsResponse;
             readonly kind: MethodKind.Unary;
         };
         /**
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.SetApplicationManifests
+         * GetEnvs gets multiple environment variables for an application/version.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.GetEnvs
          */
-        readonly setApplicationManifests: {
-            readonly name: "SetApplicationManifests";
-            readonly I: typeof SetApplicationManifestsRequest;
-            readonly O: typeof SetApplicationManifestsResponse;
+        readonly getEnvs: {
+            readonly name: "GetEnvs";
+            readonly I: typeof GetEnvsRequest;
+            readonly O: typeof GetEnvsResponse;
             readonly kind: MethodKind.Unary;
         };
         /**
-         * UploadBundle uploads a bundle for a specific application version.
+         * Release allows a deployed application to converge.
          *
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.UploadBundle
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.Release
          */
-        readonly uploadBundle: {
-            readonly name: "UploadBundle";
-            readonly I: typeof UploadBundleRequest;
-            readonly O: typeof UploadBundleResponse;
+        readonly release: {
+            readonly name: "Release";
+            readonly I: typeof ReleaseRequest;
+            readonly O: typeof ReleaseResponse;
             readonly kind: MethodKind.Unary;
         };
         /**
-         * StatBundle returns the metadata for a bundle.
+         * Watch attaches a watcher to the ring buffer associated with an application.
+         *
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.Watch
+         */
+        readonly watch: {
+            readonly name: "Watch";
+            readonly I: typeof WatchRequest;
+            readonly O: typeof WatchResponse;
+            readonly kind: MethodKind.ServerStreaming;
+        };
+        /**
+         * Delete sets an application to deleting.
          *
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.StatBundle
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.Delete
          */
-        readonly statBundle: {
-            readonly name: "StatBundle";
-            readonly I: typeof StatBundleRequest;
-            readonly O: typeof StatBundleResponse;
+        readonly delete: {
+            readonly name: "Delete";
+            readonly I: typeof DeleteRequest;
+            readonly O: typeof DeleteResponse;
             readonly kind: MethodKind.Unary;
         };
         /**
-         * SetEnv sets an environment variable for an application/version.
+         * setActive sets application active/inactive (start/stop) state.
          *
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.SetEnv
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.SetActive
          */
-        readonly setEnv: {
-            readonly name: "SetEnv";
-            readonly I: typeof SetEnvRequest;
-            readonly O: typeof SetEnvResponse;
+        readonly setActive: {
+            readonly name: "SetActive";
+            readonly I: typeof SetActiveRequest;
+            readonly O: typeof SetActiveResponse;
             readonly kind: MethodKind.Unary;
         };
         /**
-         * GetEnv gets an environment variable for an application/version.
+         * setSandbox sets application sandboxed/unsandboxed state.
          *
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.GetEnv
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.SetSandbox
          */
-        readonly getEnv: {
-            readonly name: "GetEnv";
-            readonly I: typeof GetEnvRequest;
-            readonly O: typeof GetEnvResponse;
+        readonly setSandbox: {
+            readonly name: "SetSandbox";
+            readonly I: typeof SetSandboxRequest;
+            readonly O: typeof SetSandboxResponse;
             readonly kind: MethodKind.Unary;
         };
         /**
-         * QueryResources returns the physical underlying resources for a given query
+         * Status returns the status of an application@version.
          *
-         * @generated from rpc liquidmetal.v1alpha1.CatalogService.QueryResources
+         * @generated from rpc liquidmetal.v1alpha1.CatalogService.Status
          */
-        readonly queryResources: {
-            readonly name: "QueryResources";
-            readonly I: typeof QueryResourcesRequest;
-            readonly O: typeof QueryResourcesResponse;
+        readonly status: {
+            readonly name: "Status";
+            readonly I: typeof StatusRequest;
+            readonly O: typeof StatusResponse;
             readonly kind: MethodKind.Unary;
         };
     };

package/dist/liquidmetal/v1alpha1/catalog_connect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog_connect.d.ts","sourceRoot":"","sources":["../../../src/liquidmetal/v1alpha1/catalog_connect.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,aAAa,EAAE,cAAc,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,iCAAiC,EAAE,kCAAkC,EAAE,8BAA8B,EAAE,+BAA+B,EAAE,aAAa,EAAE,cAAc,EAAE,8BAA8B,EAAE,+BAA+B,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACvrB,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc;;;QAGvB;;;;;WAKG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;;;;;WAMG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;WAEG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;;CAQG,CAAC"}
+{"version":3,"file":"catalog_connect.d.ts","sourceRoot":"","sources":["../../../src/liquidmetal/v1alpha1/catalog_connect.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,cAAc,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,aAAa,EAAE,cAAc,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACpf,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc;;;QAGvB;;;;WAIG;;;;;;;QAOH;;;;;WAKG;;;;;;;QAOH;;;;;;WAMG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;QAOH;;;;WAIG;;;;;;;;CAQG,CAAC"}