@liquidmetal-ai/drizzle 0.0.4 → 0.1.1

package/dist/unsafe/framework.test.js

@@ -0,0 +1,175 @@
+import { exec } from 'node:child_process';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getPackageVersion } from './framework.js';
+vi.mock('node:child_process', () => ({
+    exec: vi.fn(),
+}));
+describe('getPackageVersion', () => {
+    let tempDir;
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        // Create a new temp directory for each test
+        tempDir = join(tmpdir(), `test-${Date.now()}`);
+        await mkdir(tempDir, { recursive: true });
+        // Mock process.cwd() to return our temp directory
+        vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+    });
+    it('should detect npm package version', async () => {
+        // Create package-lock.json to indicate npm
+        await writeFile(join(tempDir, 'package-lock.json'), JSON.stringify({ name: 'test' }));
+        // Mock npm list command output
+        vi.mocked(exec).mockImplementation((command, callback) => {
+            if (command.includes('npm list')) {
+                callback(null, {
+                    stdout: JSON.stringify({
+                        dependencies: {
+                            'test-package': {
+                                version: '1.2.3',
+                            },
+                        },
+                    }),
+                    stderr: '',
+                });
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return {};
+        });
+        const version = await getPackageVersion('test-package');
+        expect(version).toBe('1.2.3');
+    });
+    it('should detect yarn package version', async () => {
+        // Create yarn.lock to indicate yarn
+        await writeFile(join(tempDir, 'yarn.lock'), 'yarn lock contents');
+        // Mock yarn list command output
+        vi.mocked(exec).mockImplementation((command, callback) => {
+            if (command.includes('yarn list')) {
+                callback(null, {
+                    stdout: JSON.stringify({
+                        data: {
+                            trees: [
+                                {
+                                    name: 'test-package',
+                                    version: '2.3.4',
+                                },
+                            ],
+                        },
+                    }),
+                    stderr: '',
+                });
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return {};
+        });
+        const version = await getPackageVersion('test-package');
+        expect(version).toBe('2.3.4');
+    });
+    it('should detect pnpm package version', async () => {
+        // Create pnpm-lock.yaml to indicate pnpm
+        await writeFile(join(tempDir, 'pnpm-lock.yaml'), 'pnpm lock contents');
+        // Mock pnpm list command output
+        vi.mocked(exec).mockImplementation((command, callback) => {
+            if (command.includes('pnpm list')) {
+                callback(null, {
+                    stdout: JSON.stringify({
+                        dependencies: {
+                            'test-package': {
+                                version: '3.4.5',
+                            },
+                        },
+                    }),
+                    stderr: '',
+                });
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return {};
+        });
+        const version = await getPackageVersion('test-package');
+        expect(version).toBe('3.4.5');
+    });
+    it('should handle nested dependencies', async () => {
+        await writeFile(join(tempDir, 'package-lock.json'), JSON.stringify({ name: 'test' }));
+        vi.mocked(exec).mockImplementation((command, callback) => {
+            if (command.includes('npm list')) {
+                callback(null, {
+                    stdout: JSON.stringify({
+                        dependencies: {
+                            'parent-package': {
+                                version: '1.0.0',
+                                dependencies: {
+                                    'test-package': {
+                                        version: '4.5.6',
+                                    },
+                                },
+                            },
+                        },
+                    }),
+                    stderr: '',
+                });
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return {};
+        });
+        const version = await getPackageVersion('test-package');
+        expect(version).toBe('4.5.6');
+    });
+    it('should return null when package is not found', async () => {
+        await writeFile(join(tempDir, 'package-lock.json'), JSON.stringify({ name: 'test' }));
+        vi.mocked(exec).mockImplementation((command, callback) => {
+            if (command.includes('npm list')) {
+                callback(null, {
+                    stdout: JSON.stringify({
+                        dependencies: {},
+                    }),
+                    stderr: '',
+                });
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return {};
+        });
+        const version = await getPackageVersion('non-existent-package');
+        expect(version).toBeNull();
+    });
+    it('should search parent directories for package manager files', async () => {
+        // Create a nested directory structure
+        const nestedDir = join(tempDir, 'nested', 'deeper');
+        await mkdir(nestedDir, { recursive: true });
+        // Create package-lock.json in parent directory
+        await writeFile(join(tempDir, 'package-lock.json'), JSON.stringify({ name: 'test' }));
+        // Set cwd to nested directory
+        vi.spyOn(process, 'cwd').mockReturnValue(nestedDir);
+        vi.mocked(exec).mockImplementation((command, callback) => {
+            if (command.includes('npm list')) {
+                callback(null, {
+                    stdout: JSON.stringify({
+                        dependencies: {
+                            'test-package': {
+                                version: '5.6.7',
+                            },
+                        },
+                    }),
+                    stderr: '',
+                });
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return {};
+        });
+        const version = await getPackageVersion('test-package');
+        expect(version).toBe('5.6.7');
+    });
+    it('should handle command execution errors', async () => {
+        await writeFile(join(tempDir, 'package-lock.json'), JSON.stringify({ name: 'test' }));
+        vi.mocked(exec).mockImplementation((_command, callback) => {
+            callback(new Error('Command failed'), {
+                stdout: '',
+                stderr: 'failure',
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return {};
+        });
+        const version = await getPackageVersion('test-package');
+        expect(version).toBeNull();
+    });
+});

package/eslint.config.mjs

@@ -1,4 +1,3 @@
 import repo_config from '@repo/eslint-config/eslint.config.mjs';
 
-export default repo_config.concat([
-]);
+export default repo_config.concat([]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liquidmetal-ai/drizzle",
-  "version": "0.0.4",
+  "version": "0.1.1",
   "description": "Raindrop core operational libraries",
   "type": "module",
   "scripts": {

package/src/appify/build.test.ts

@@ -60,9 +60,7 @@ application "my-app" {
     visibility = 'application'
   }
 
-  sql_database "my-database" {
-    schema = "my-schema.sql"
-  }
+  sql_database "my-database" {}
 
   vector_index "my-index" {
     dimension = 768

package/src/appify/build.ts

@@ -345,9 +345,6 @@ function buildSqlDatabase(stanza: StanzaNode): [SqlDatabase, ConfigError[]] {
           case 'visibility':
             buildAssignment(sqlDatabase, 'visibility', 'string', child, errors);
             break;
-          case 'schema':
-            buildAssignment(sqlDatabase, 'schema', 'string', child, errors);
-            break;
           default:
             errors.push({ message: 'unexpected assignment', ...child });
         }
@@ -543,6 +540,9 @@ function buildDomain(stanza: StanzaNode): [Domain, ConfigError[]] {
   for (const child of stanza.block?.children ?? []) {
     if (child.type === 'assignment') {
       switch (child.key.value) {
+        case 'cname':
+          buildAssignment(domain, 'cname', 'string', child, errors);
+          break;
         case 'fqdn':
           buildAssignment(domain, 'fqdn', 'string', child, errors);
           break;
@@ -703,6 +703,7 @@ export class Route {
 
 export class Domain {
   obj: ConfigObject;
+  cname?: TokenString;
   fqdn?: TokenString;
 
   constructor(obj: ConfigObject) {

package/src/appify/index.test.ts

@@ -29,8 +29,8 @@ test('mustManifestFromString with warnings', async () => {
   const manifest = `
 application "app" {
   service "svc" {
-    domain {
-      fqdn = "bad_domain_name"
+    env "not_uppercase" {
+      default = "not_uppercase"
     }
   }
 }

package/src/appify/parse.test.ts

@@ -244,7 +244,6 @@ application "my-app" {
 `);
   const parser = new Parser(tokenizer);
   parser.parse();
-  console.log(parser.errors);
   expect(parser.errors).toHaveLength(1);
 });
 

package/src/appify/validate.test.ts

@@ -55,32 +55,129 @@ application "my-app" {
   ]);
 });
 
-// test('domainValidator', async () => {
-//   const manifest = `
-// application "my-app" {
-//   service "my-service" {
-//     domain {
-//       fqdn = "not-valid.com_foo"
-//     }
-//   }
-// }
-// `;
-//   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: 'domain "not-valid.com_foo" is an invalid domain name',
-//       line: 5,
-//       column: 14,
-//       start: 75,
-//       end: 94,
-//       severity: 'warning',
-//     },
-//   ]);
-// });
+test('domainValidator ensures domain.fqdn is valid', async () => {
+  const manifest = `
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "not-valid.com_foo"
+    }
+  }
+}
+`;
+  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: 'domain "not-valid.com_foo" is an invalid domain name',
+      line: 4,
+      column: 5,
+      start: 53,
+      end: 100,
+      severity: 'error',
+    },
+  ]);
+});
+
+test('domainValidator ensures domain.fqdn is valid but ignores variable interpolation', async () => {
+  const manifest = `
+application "my-app" {
+  service "my-service" {
+    domain {
+      fqdn = "$\{MY_SERVICES_EXAMPLE_URL}"
+    }
+  }
+}
+`;
+  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).toEqual([]);
+});
+
+test('domainValidator ensures either a cname or fqdn present', async () => {
+  const manifest = `
+application "my-app" {
+  service "my-service" {
+    domain {}
+  }
+}
+`;
+  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: 'domain must have either a cname or fqdn attribute',
+      line: 4,
+      column: 5,
+      start: 53,
+      end: 62,
+      severity: 'error',
+    },
+  ]);
+});
+
+test('domainValidator ensures ensures domain.cname is valid', async () => {
+  const manifest = `
+application "my-app" {
+  service "my-service" {
+    domain {
+      cname = "my_cname"
+    }
+  }
+}
+`;
+  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: 'domain "my_cname" is an invalid subdomain name',
+      line: 4,
+      column: 5,
+      start: 53,
+      end: 92,
+      severity: 'error',
+    },
+  ]);
+});
+
+test('domainValidator validates domain.cname does not exceed the maximum length', async () => {
+  const manifest = `
+application "my-app" {
+  service "my-service" {
+    domain {
+      cname = "really-long-cname-that-is-invalid-because-it-is-too-long"
+    }
+  }
+}
+`;
+  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: 'domain.cname undefined is too long, maximum 26 characters',
+      line: 4,
+      column: 5,
+      start: 53,
+      end: 140,
+      severity: 'error',
+    },
+  ]);
+});
 
 test('visibilityValidator', async () => {
   const manifest = `

package/src/appify/validate.ts

@@ -203,23 +203,54 @@ const bindingValueValidator: Validator = {
   },
 };
 
-// Disabled for now.
-const _domainValidator: Validator = {
+const VALIDATE_DOMAIN_PATTERN = /^[a-z0-9]+([-.]{1}[a-z0-9]+)*\.[a-z]{2,6}$/;
+const FQDN_MAX_LENGTH = 63;
+const CNAME_MAX_LENGTH = 63 - `.01abcdefghijklmnopqrstuvwx.lmapp.run`.length;
+
+const domainValidator: Validator = {
   onDomain: async (app: Application, domain: Domain): Promise<ValidationError[]> => {
     const errors: ValidationError[] = [];
-    if (domain.fqdn === undefined) {
+    if (domain.cname == undefined && domain.fqdn === undefined) {
       errors.push({
-        message: 'domain must have an fqdn',
+        message: 'domain must have either a cname or fqdn attribute',
         severity: 'error',
         ...domain.obj,
       });
-    } else if (!/^[a-z0-9]+([-.]{1}[a-z0-9]+)*\.[a-z]{2,6}$/.test(valueOf(domain.fqdn))) {
+      return errors;
+    }
+    if (
+      domain.fqdn !== undefined &&
+      valueOf(domain.fqdn).indexOf('${') === -1 &&
+      !VALIDATE_DOMAIN_PATTERN.test(valueOf(domain.fqdn))
+    ) {
       errors.push({
         message: `domain ${domain.fqdn.value} is an invalid domain name`,
-        severity: 'warning',
-        ...domain.fqdn,
+        severity: 'error',
+        ...domain.obj,
+      });
+    }
+    if (domain.cname !== undefined && !VALIDATE_DOMAIN_PATTERN.test(`${valueOf(domain.cname)}.example.com`)) {
+      errors.push({
+        message: `domain ${domain.cname.value} is an invalid subdomain name`,
+        severity: 'error',
+        ...domain.obj,
+      });
+    }
+    if (domain.cname !== undefined && valueOf(domain.cname).length > CNAME_MAX_LENGTH) {
+      errors.push({
+        message: `domain.cname ${domain.fqdn} is too long, maximum ${CNAME_MAX_LENGTH} characters`,
+        severity: 'error',
+        ...domain.obj,
       });
     }
+    if (domain.fqdn !== undefined && valueOf(domain.fqdn).length > FQDN_MAX_LENGTH) {
+      errors.push({
+        message: `domain.fqdn ${domain.fqdn} is too long, maximum ${FQDN_MAX_LENGTH} characters`,
+        severity: 'error',
+        ...domain.obj,
+      });
+    }
+
     return errors;
   },
 };
@@ -438,6 +469,7 @@ const duplicateModuleValidator: Validator = {
 export const VALIDATORS: Validator[] = [
   bindingNameValidator,
   bindingValueValidator,
+  domainValidator,
   envValidator,
   observerSourceValidator,
   visibilityValidator,

package/src/codestore.ts

@@ -1,16 +1,28 @@
 import crypto from 'crypto';
 import JSZip from 'jszip';
 
-// CodeStore is a mapping of a handler name to a bundle of code.
+/**
+ * CodeStore represents a collection of code bundles mapped by handler names
+ * Used to organize and manage multiple code bundles in a single namespace
+ */
 export interface CodeStore {
   [key: string]: Bundle;
 }
 
+/**
+ * Statistics about a file in a bundle
+ * Includes size and cryptographic hash information
+ */
 export interface Stat {
   sizeBytes: number;
   sha256Hex: string;
 }
 
+/**
+ * Interface for read-only access to a bundle of files
+ * Provides methods to list, read, and get statistics about files
+ * Also supports async iteration over files
+ */
 export interface ReadableBundle {
   list(): Promise<string[]>;
   read(name: string): Promise<Buffer>;
@@ -19,19 +31,36 @@ export interface ReadableBundle {
   hash(): Promise<string>;
 }
 
+/**
+ * Interface for write operations on a bundle of files
+ * Provides methods to write and delete files
+ */
 export interface WritableBundle {
   write(name: string, content: Buffer): Promise<void>;
   delete(name: string): Promise<void>;
 }
 
+/**
+ * Complete interface for a bundle of files
+ * Combines both read and write operations
+ */
 export type Bundle = ReadableBundle & WritableBundle;
 
+/**
+ * Represents a single file within a bundle
+ * Provides methods to read the file's contents and get its statistics
+ */
 export interface File {
   name: string;
   read(): Promise<Buffer>;
   stat(): Promise<Stat>;
 }
 
+/**
+ * Base implementation of ReadableBundle
+ * Provides default implementations for stat(), hash() and async iteration
+ * Concrete implementations must provide list() and read() methods
+ */
 export abstract class BundleBase implements ReadableBundle {
   abstract list(): Promise<string[]>;
   abstract read(name: string): Promise<Buffer>;
@@ -73,6 +102,11 @@ export abstract class BundleBase implements ReadableBundle {
   }
 }
 
+/**
+ * Creates a ZIP archive containing all files from a bundle
+ * @param bundle The bundle to archive
+ * @returns Promise resolving to the ZIP file contents as an ArrayBuffer
+ */
 export async function archive(bundle: ReadableBundle): Promise<ArrayBuffer> {
   const zip = new JSZip();
   for await (const file of bundle) {
@@ -81,6 +115,11 @@ export async function archive(bundle: ReadableBundle): Promise<ArrayBuffer> {
   return await zip.generateAsync({ type: 'arraybuffer' });
 }
 
+/**
+ * Extracts files from a ZIP archive into a writable bundle
+ * @param zipBuffer The ZIP file contents as an ArrayBuffer
+ * @param bundle The target bundle to write the extracted files to
+ */
 export async function unarchive(zipBuffer: ArrayBuffer, bundle: WritableBundle): Promise<void> {
   const zip = await JSZip.loadAsync(zipBuffer);
   for (const [, file] of Object.entries(zip.files)) {

package/src/liquidmetal/v1alpha1/catalog_connect.ts

@@ -23,6 +23,18 @@ import { MethodKind } from "@bufbuild/protobuf";
 export const CatalogService = {
   typeName: "liquidmetal.v1alpha1.CatalogService",
   methods: {
+    /**
+     * Bootstrap is a special RPC that is used to bootstrap the system
+     * using a one-time token.
+     *
+     * @generated from rpc liquidmetal.v1alpha1.CatalogService.Bootstrap
+     */
+    bootstrap: {
+      name: "Bootstrap",
+      I: BootstrapRequest,
+      O: BootstrapResponse,
+      kind: MethodKind.Unary,
+    },
     /**
      * @generated from rpc liquidmetal.v1alpha1.CatalogService.Versions
      */
@@ -154,18 +166,6 @@ export const CatalogService = {
       O: QueryResourcesResponse,
       kind: MethodKind.Unary,
     },
-    /**
-     * Bootstrap is a special RPC that is used to bootstrap the system
-     * using a one-time token.
-     *
-     * @generated from rpc liquidmetal.v1alpha1.CatalogService.Bootstrap
-     */
-    bootstrap: {
-      name: "Bootstrap",
-      I: BootstrapRequest,
-      O: BootstrapResponse,
-      kind: MethodKind.Unary,
-    },
   }
 } as const;