@liquidmetal-ai/drizzle 0.9.2 → 0.11.0

package/src/appify/build.test.ts

@@ -581,3 +581,187 @@ application "my-agent-app" {
   expect(valueOf(app.service[0]!.name)).toBe('agent-api');
   expect(valueOf(app.bucket[0]!.name)).toBe('agent-files');
 });
+
+test('payments basic parsing', () => {
+  const CONFIG = `
+application "my-app" {
+  payments {
+  }
+}
+`;
+  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 payments
+  expect(apps[0]!.payments.length).toBe(1);
+
+  // Check the payments properties
+  const payments = apps[0]!.payments[0]!;
+  expect(valueOf(payments.name)).toBe('payments');
+  expect(payments.mode).toBeUndefined();
+});
+
+test('payments with mode=test', () => {
+  const CONFIG = `
+application "my-app" {
+  payments {
+    mode = "test"
+  }
+}
+`;
+  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 payments
+  expect(apps[0]!.payments.length).toBe(1);
+
+  // Check the payments properties
+  const payments = apps[0]!.payments[0]!;
+  expect(valueOf(payments.name)).toBe('payments');
+  expect(payments.mode).toBeDefined();
+  expect(valueOf(payments.mode!)).toBe('test');
+});
+
+test('payments with mode=live', () => {
+  const CONFIG = `
+application "my-app" {
+  payments {
+    mode = "live"
+  }
+}
+`;
+  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 payments
+  expect(apps[0]!.payments.length).toBe(1);
+
+  // Check the payments properties
+  const payments = apps[0]!.payments[0]!;
+  expect(valueOf(payments.name)).toBe('payments');
+  expect(payments.mode).toBeDefined();
+  expect(valueOf(payments.mode!)).toBe('live');
+});
+
+test('payments with invalid properties', () => {
+  const CONFIG = `
+application "my-app" {
+  payments {
+    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('payments with duplicate mode assignment', () => {
+  const CONFIG = `
+application "my-app" {
+  payments {
+    mode = "test"
+    mode = "live"
+  }
+}
+`;
+  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 duplicate assignment
+  expect(errors.length).toBe(1);
+  expect(errors[0]!.message).toContain('duplicate');
+});
+
+test('payments with invalid mode value', () => {
+  const CONFIG = `
+application "my-app" {
+  payments {
+    mode = "production"
+  }
+}
+`;
+  const tokenizer = new Tokenizer(CONFIG);
+  const parser = new Parser(tokenizer);
+  const ast = parser.parse();
+  expect(parser.errors).toEqual([]);
+
+  const [_apps, errors] = buildManifest(ast);
+
+  // Should have one error for the invalid mode value
+  expect(errors.length).toBe(1);
+  expect(errors[0]!.message).toContain('mode must be either "live" or "test"');
+  expect(errors[0]!.message).toContain('production');
+});
+
+test('payments integration with other modules', () => {
+  const CONFIG = `
+application "my-payment-app" {
+  payments {
+    mode = "test"
+  }
+
+  service "api" {
+  }
+
+  actor "processor" {
+    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
+  expect(apps.length).toBe(1);
+  const app = apps[0]!;
+
+  // Verify all module types are parsed correctly
+  expect(app.payments.length).toBe(1);
+  expect(app.service.length).toBe(1);
+  expect(app.actor.length).toBe(1);
+
+  // Verify payments properties
+  const payments = app.payments[0]!;
+  expect(valueOf(payments.name)).toBe('payments');
+  expect(payments.mode).toBeDefined();
+  expect(valueOf(payments.mode!)).toBe('test');
+
+  // Verify other modules still work correctly
+  expect(valueOf(app.service[0]!.name)).toBe('api');
+  expect(valueOf(app.actor[0]!.name)).toBe('processor');
+});

package/src/appify/build.ts

@@ -80,6 +80,27 @@ export function buildManifest(node: BlockNode): [Application[], ConfigError[]] {
   return [applications, errors];
 }
 
+// buildName0 is a helper function for stanzas that don't take a name argument.
+// It generates a hardcoded name token based on the stanza type.
+function buildName0(stanzaName: string, node: StanzaNode): [TokenString, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  if (node.args.length > 0) {
+    errors.push({ message: `${stanzaName} does not take a name argument`, ...node.args[0]! });
+  }
+  // Generate a token with the hardcoded name
+  return [
+    {
+      type: 'string',
+      value: `"${stanzaName}"`,
+      line: node.line,
+      column: node.column,
+      start: node.start,
+      end: node.block?.start || node.end,
+    } as TokenString,
+    errors,
+  ];
+}
+
 // buildName1 is a helper function for parsing a name from a stanza
 // node arguments and asserting there should only be 1, string
 // argument.
@@ -252,6 +273,9 @@ export function buildApplication(node: StanzaNode): [Application | undefined, Co
           case 'smartmemory':
             buildStanza(buildSmartMemory, child, app.smartMemory, errors);
             break;
+          case 'payments':
+            buildStanza(buildPayments, child, app.payments, errors);
+            break;
           default:
             errors.push({ message: 'unexpected stanza', ...child });
         }
@@ -602,6 +626,42 @@ function buildSmartMemory(stanza: StanzaNode): [SmartMemory, ConfigError[]] {
   return [smartMemory, errors];
 }
 
+function buildPayments(stanza: StanzaNode): [Payments, ConfigError[]] {
+  const errors: ConfigError[] = [];
+  const [name, nameErrors] = buildName0('payments', stanza);
+  errors.push(...nameErrors);
+  const payments = new Payments(name, stanza);
+  for (const child of stanza.block?.children ?? []) {
+    switch (child.type) {
+      case 'assignment':
+        switch (child.key.value) {
+          case 'mode':
+            buildAssignment(payments, 'mode', 'string', child, errors);
+            // Validate that mode is either "live" or "test"
+            if (payments.mode && child.value.type === 'string') {
+              const modeValue = valueOf(payments.mode);
+              if (modeValue !== 'live' && modeValue !== 'test') {
+                errors.push({
+                  message: `mode must be either "live" or "test", got "${modeValue}"`,
+                  ...child.value
+                });
+              }
+            }
+            break;
+          default:
+            errors.push({ message: 'unexpected assignment', ...child });
+        }
+        break;
+      case 'comment':
+      case 'newline':
+        break;
+      default:
+        errors.push({ message: `unexpected ${child.type}`, ...child });
+    }
+  }
+  return [payments, errors];
+}
+
 function buildObserver(stanza: StanzaNode): [Observer, ConfigError[]] {
   const errors: ConfigError[] = [];
   const [name, nameErrors] = buildName1(stanza);
@@ -922,6 +982,7 @@ export class Application {
   smartBucket: SmartBucket[] = [];
   smartSql: SmartSql[] = [];
   smartMemory: SmartMemory[] = [];
+  payments: Payments[] = [];
   labels: Record<string, string> = {};
   mcpService: McpService[] = [];
 
@@ -1186,7 +1247,18 @@ export class SmartMemory {
   }
 }
 
-export const VISIBILITIES = ['none', 'public', 'private', 'protected', 'application', 'suite', 'tenant'] as const;
+export class Payments {
+  name: TokenString;
+  obj: ConfigObject;
+  mode?: TokenString;
+
+  constructor(name: TokenString, obj: ConfigObject) {
+    this.name = name;
+    this.obj = obj;
+  }
+}
+
+export const VISIBILITIES = ['none', 'public', 'private', 'protected', 'paid', 'application', 'suite', 'tenant'] as const;
 export type Visibility = (typeof VISIBILITIES)[number];
 
 export const TASK_TYPES = ['cron'] as const;

package/src/appify/validate.test.ts

@@ -225,7 +225,7 @@ application "my-app" {
   const validateErrors = await validate(builtApps, VALIDATORS);
   expect(validateErrors).toMatchObject([
     {
-      message: 'visibility must be one of none, public, private, protected, application, suite, tenant',
+      message: 'visibility must be one of none, public, private, protected, paid, application, suite, tenant',
       line: 4,
       column: 18,
       start: 66,
@@ -533,3 +533,42 @@ describe('task validator', async () => {
     }
   });
 });
+
+test('paymentsValidator - multiple payments blocks', async () => {
+  const manifest = `
+application "my-app" {
+  payments {}
+
+  payments {}
+}
+`;
+  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: 'only one payments block is allowed per application',
+      line: 5,
+      column: 3,
+      severity: 'error',
+    },
+  ]);
+});
+
+test('paymentsValidator - single payments block', async () => {
+  const manifest = `
+application "my-app" {
+  payments {}
+}
+`;
+  const tokenizer = new Tokenizer(manifest);
+  const parser = new Parser(tokenizer);
+  const parsedManifest = parser.parse();
+  const [builtApps] = buildManifest(parsedManifest);
+  const validateErrors = await validate(builtApps, VALIDATORS);
+  // Filter out other validation errors, only check for payments-related errors
+  const paymentsErrors = validateErrors.filter((e) => e.message.includes('payments'));
+  expect(paymentsErrors).toEqual([]);
+});

package/src/appify/validate.ts

@@ -543,6 +543,44 @@ const locationHintValidator: Validator = {
   },
 };
 
+const paymentsValidator: Validator = {
+  onApplication: async (app: Application, _application: Application): Promise<ValidationError[]> => {
+    const errors: ValidationError[] = [];
+    if (app.payments.length > 1) {
+      // Report error on the second payments declaration
+      const secondPayments = app.payments[1];
+      if (secondPayments) {
+        errors.push({
+          message: 'only one payments block is allowed per application',
+          severity: 'error',
+          ...secondPayments.obj,
+        });
+      }
+    }
+    return errors;
+  },
+};
+
+async function paidVisibilityValidatorFn(app: Application, obj: { visibility?: TokenString }): Promise<ValidationError[]> {
+  const errors: ValidationError[] = [];
+  if (obj.visibility && valueOf(obj.visibility) === 'paid' && app.payments.length === 0) {
+    errors.push({
+      message: 'visibility="paid" requires a payments block in the application manifest',
+      severity: 'error',
+      ...(obj.visibility || obj),
+    });
+  }
+  return errors;
+}
+
+const paidVisibilityValidator: Validator = {
+  onService: paidVisibilityValidatorFn,
+  onActor: paidVisibilityValidatorFn,
+  onTask: paidVisibilityValidatorFn,
+  onQueue: paidVisibilityValidatorFn,
+  onBucket: paidVisibilityValidatorFn,
+};
+
 export const VALIDATORS: Validator[] = [
   bindingNameValidator,
   bindingValueValidator,
@@ -555,4 +593,6 @@ export const VALIDATORS: Validator[] = [
   vectorIndexValidator,
   duplicateModuleValidator,
   locationHintValidator,
+  paymentsValidator,
+  paidVisibilityValidator,
 ];

package/src/liquidmetal/v1alpha1/bucket_name_pb.ts

@@ -10,10 +10,10 @@ import type { Message } from "@bufbuild/protobuf";
  * Describes the file liquidmetal/v1alpha1/bucket_name.proto.
  */
 export const file_liquidmetal_v1alpha1_bucket_name: GenFile = /*@__PURE__*/
-  fileDesc("CiZsaXF1aWRtZXRhbC92MWFscGhhMS9idWNrZXRfbmFtZS5wcm90bxIUbGlxdWlkbWV0YWwudjFhbHBoYTEicAoKQnVja2V0TmFtZRIMCgRuYW1lGAEgASgJEhQKB3ZlcnNpb24YAiABKAlIAIgBARIdChBhcHBsaWNhdGlvbl9uYW1lGAMgASgJSAGIAQFCCgoIX3ZlcnNpb25CEwoRX2FwcGxpY2F0aW9uX25hbWUiawoNQnVja2V0TG9jYXRvchITCgltb2R1bGVfaWQYASABKAlIABIyCgZidWNrZXQYAiABKAsyIC5saXF1aWRtZXRhbC52MWFscGhhMS5CdWNrZXROYW1lSABCEQoPYnVja2V0X2xvY2F0aW9uInIKDkJ1Y2tldFJlc3BvbnNlEhEKCW1vZHVsZV9pZBgBIAEoCRITCgtidWNrZXRfbmFtZRgCIAEoCRIeChZhcHBsaWNhdGlvbl92ZXJzaW9uX2lkGAQgASgJEhgKEGFwcGxpY2F0aW9uX25hbWUYBSABKAlC6gEKGGNvbS5saXF1aWRtZXRhbC52MWFscGhhMUIPQnVja2V0TmFtZVByb3RvUAFaTGdpdGh1Yi5jb20vbGlxdWlkbWV0YWwtYWkvcHJvdG9nZW4yL2xpcXVpZG1ldGFsL3YxYWxwaGExO2xpcXVpZG1ldGFsdjFhbHBoYTGiAgNMWFiqAhRMaXF1aWRtZXRhbC5WMWFscGhhMcoCFExpcXVpZG1ldGFsXFYxYWxwaGEx4gIgTGlxdWlkbWV0YWxcVjFhbHBoYTFcR1BCTWV0YWRhdGHqAhVMaXF1aWRtZXRhbDo6VjFhbHBoYTFiBnByb3RvMw");
+  fileDesc("CiZsaXF1aWRtZXRhbC92MWFscGhhMS9idWNrZXRfbmFtZS5wcm90bxIUbGlxdWlkbWV0YWwudjFhbHBoYTEiRQoKQnVja2V0TmFtZRIMCgRuYW1lGAEgASgJEg8KB3ZlcnNpb24YAiABKAkSGAoQYXBwbGljYXRpb25fbmFtZRgDIAEoCSJrCg1CdWNrZXRMb2NhdG9yEhMKCW1vZHVsZV9pZBgBIAEoCUgAEjIKBmJ1Y2tldBgCIAEoCzIgLmxpcXVpZG1ldGFsLnYxYWxwaGExLkJ1Y2tldE5hbWVIAEIRCg9idWNrZXRfbG9jYXRpb24icgoOQnVja2V0UmVzcG9uc2USEQoJbW9kdWxlX2lkGAEgASgJEhMKC2J1Y2tldF9uYW1lGAIgASgJEh4KFmFwcGxpY2F0aW9uX3ZlcnNpb25faWQYBCABKAkSGAoQYXBwbGljYXRpb25fbmFtZRgFIAEoCULqAQoYY29tLmxpcXVpZG1ldGFsLnYxYWxwaGExQg9CdWNrZXROYW1lUHJvdG9QAVpMZ2l0aHViLmNvbS9saXF1aWRtZXRhbC1haS9wcm90b2dlbjIvbGlxdWlkbWV0YWwvdjFhbHBoYTE7bGlxdWlkbWV0YWx2MWFscGhhMaICA0xYWKoCFExpcXVpZG1ldGFsLlYxYWxwaGExygIUTGlxdWlkbWV0YWxcVjFhbHBoYTHiAiBMaXF1aWRtZXRhbFxWMWFscGhhMVxHUEJNZXRhZGF0YeoCFUxpcXVpZG1ldGFsOjpWMWFscGhhMWIGcHJvdG8z");
 
 /**
- * BucketName represents a bucket name with an optional version
+ * BucketName represents a bucket name with version and application name
  *
  * @generated from message liquidmetal.v1alpha1.BucketName
  */
@@ -28,22 +28,22 @@ export type BucketName = Message<"liquidmetal.v1alpha1.BucketName"> & {
   name: string;
 
   /**
-   * Optional version of the bucket
+   * The version of the bucket
    * __EXAMPLE__ "01jtryx2f2f61ryk06vd8mr91p"
-   * __REQUIRED__ FALSE
+   * __REQUIRED__ TRUE
    *
-   * @generated from field: optional string version = 2;
+   * @generated from field: string version = 2;
    */
-  version?: string;
+  version: string;
 
   /**
-   * Optional Application
+   * The application name
    * __EXAMPLE__ "my-app"
-   * __REQUIRED__ FALSE
+   * __REQUIRED__ TRUE
    *
-   * @generated from field: optional string application_name = 3;
+   * @generated from field: string application_name = 3;
    */
-  applicationName?: string;
+  applicationName: string;
 };
 
 /**
@@ -58,7 +58,7 @@ export const BucketNameSchema: GenMessage<BucketName> = /*@__PURE__*/
  */
 export type BucketLocator = Message<"liquidmetal.v1alpha1.BucketLocator"> & {
   /**
-   * __EXAMPLE__ { name: 'my-smartbucket' }
+   * __EXAMPLE__ { name: 'my-smartbucket', version: '01jtryx2f2f61ryk06vd8mr91p', application_name: 'my-app' }
    * __REQUIRED__ TRUE
    *
    * @generated from oneof liquidmetal.v1alpha1.BucketLocator.bucket_location
@@ -74,7 +74,7 @@ export type BucketLocator = Message<"liquidmetal.v1alpha1.BucketLocator"> & {
     case: "moduleId";
   } | {
     /**
-     * __EXAMPLE__ { name: 'my-smartbucket' }
+     * __EXAMPLE__ { name: 'my-smartbucket', version: '01jtryx2f2f61ryk06vd8mr91p', application_name: 'my-app' }
      * __REQUIRED__ FALSE
      *
      * @generated from field: liquidmetal.v1alpha1.BucketName bucket = 2;

package/src/liquidmetal/v1alpha1/object_pb.ts

@@ -17,7 +17,7 @@ import type { Message } from "@bufbuild/protobuf";
  * Describes the file liquidmetal/v1alpha1/object.proto.
  */
 export const file_liquidmetal_v1alpha1_object: GenFile = /*@__PURE__*/
-  fileDesc("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", [file_google_protobuf_timestamp, file_liquidmetal_v1alpha1_bucket_name]);
+  fileDesc("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", [file_google_protobuf_timestamp, file_liquidmetal_v1alpha1_bucket_name]);
 
 /**
  * @generated from message liquidmetal.v1alpha1.PutObjectRequest
@@ -244,6 +244,15 @@ export type ListObjectsRequest = Message<"liquidmetal.v1alpha1.ListObjectsReques
    * @generated from field: liquidmetal.v1alpha1.BucketLocator bucket_location = 4;
    */
   bucketLocation?: BucketLocator;
+
+  /**
+   * __DESCRIPTION__ Optional prefix to filter object keys (e.g., "documents/" to only list objects in documents folder)
+   * __EXAMPLE__ "documents/"
+   * __REQUIRED__ FALSE
+   *
+   * @generated from field: optional string prefix = 5;
+   */
+  prefix?: string;
 };
 
 /**