@plures/praxis 1.0.2 → 1.1.0

package/src/__tests__/protocol.test.ts

@@ -2,39 +2,39 @@
  * Core protocol tests
  */
 
-import { describe, it, expect } from "vitest";
-import type { PraxisFact, PraxisEvent, PraxisState } from "../core/protocol.js";
+import { describe, it, expect } from 'vitest';
+import type { PraxisFact, PraxisEvent, PraxisState } from '../core/protocol.js';
 
-describe("Protocol Types", () => {
-  it("should create a valid fact", () => {
+describe('Protocol Types', () => {
+  it('should create a valid fact', () => {
     const fact: PraxisFact = {
-      tag: "TestFact",
+      tag: 'TestFact',
       payload: { value: 42 },
     };
 
-    expect(fact.tag).toBe("TestFact");
+    expect(fact.tag).toBe('TestFact');
     expect(fact.payload).toEqual({ value: 42 });
   });
 
-  it("should create a valid event", () => {
+  it('should create a valid event', () => {
     const event: PraxisEvent = {
-      tag: "TEST_EVENT",
-      payload: { action: "test" },
+      tag: 'TEST_EVENT',
+      payload: { action: 'test' },
     };
 
-    expect(event.tag).toBe("TEST_EVENT");
-    expect(event.payload).toEqual({ action: "test" });
+    expect(event.tag).toBe('TEST_EVENT');
+    expect(event.payload).toEqual({ action: 'test' });
   });
 
-  it("should create a valid state", () => {
+  it('should create a valid state', () => {
     const state: PraxisState = {
       context: { count: 0 },
-      facts: [{ tag: "CountInitialized", payload: {} }],
-      meta: { version: "1.0.0" },
+      facts: [{ tag: 'CountInitialized', payload: {} }],
+      meta: { version: '1.0.0' },
     };
 
     expect(state.context).toEqual({ count: 0 });
     expect(state.facts).toHaveLength(1);
-    expect(state.meta?.version).toBe("1.0.0");
+    expect(state.meta?.version).toBe('1.0.0');
   });
 });

package/src/__tests__/provisioning.test.ts

@@ -1,10 +1,10 @@
 /**
  * Provisioning Tests
- * 
+ *
  * Tests for auto-provisioning utilities.
  */
 
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from 'vitest';
 import {
   generateStorageNamespace,
   generateTenantId,
@@ -12,65 +12,65 @@ import {
   validateStorageNamespace,
   getAppStorageContainer,
   provisionTenant,
-} from "../cloud/provisioning.js";
-import { createFreeSubscription } from "../cloud/billing.js";
-import type { GitHubUser } from "../cloud/types.js";
+} from '../cloud/provisioning.js';
+import { createFreeSubscription } from '../cloud/billing.js';
+import type { GitHubUser } from '../cloud/types.js';
 
-describe("Provisioning", () => {
+describe('Provisioning', () => {
   const mockUser: GitHubUser = {
     id: 12345,
-    login: "testuser",
-    email: "test@example.com",
-    name: "Test User",
+    login: 'testuser',
+    email: 'test@example.com',
+    name: 'Test User',
   };
 
-  describe("generateStorageNamespace", () => {
-    it("should generate a valid namespace", () => {
-      const namespace = generateStorageNamespace("testuser", 12345);
+  describe('generateStorageNamespace', () => {
+    it('should generate a valid namespace', () => {
+      const namespace = generateStorageNamespace('testuser', 12345);
       expect(namespace).toMatch(/^gh-testuser-[a-z0-9]+$/);
       expect(namespace.length).toBeGreaterThanOrEqual(3);
       expect(namespace.length).toBeLessThanOrEqual(63);
     });
 
-    it("should sanitize special characters", () => {
-      const namespace = generateStorageNamespace("test_user-123", 12345);
+    it('should sanitize special characters', () => {
+      const namespace = generateStorageNamespace('test_user-123', 12345);
       expect(namespace).toMatch(/^gh-test-user-123-[a-z0-9]+$/);
     });
 
-    it("should convert to lowercase", () => {
-      const namespace = generateStorageNamespace("TestUser", 12345);
+    it('should convert to lowercase', () => {
+      const namespace = generateStorageNamespace('TestUser', 12345);
       expect(namespace).toMatch(/^gh-testuser-[a-z0-9]+$/);
     });
 
-    it("should generate unique namespaces for different users", () => {
-      const ns1 = generateStorageNamespace("user1", 123);
-      const ns2 = generateStorageNamespace("user1", 456);
+    it('should generate unique namespaces for different users', () => {
+      const ns1 = generateStorageNamespace('user1', 123);
+      const ns2 = generateStorageNamespace('user1', 456);
       expect(ns1).not.toBe(ns2);
     });
   });
 
-  describe("generateTenantId", () => {
-    it("should generate a tenant ID from GitHub user", () => {
+  describe('generateTenantId', () => {
+    it('should generate a tenant ID from GitHub user', () => {
       const tenantId = generateTenantId(mockUser);
-      expect(tenantId).toBe("github-12345");
+      expect(tenantId).toBe('github-12345');
     });
 
-    it("should generate unique IDs for different users", () => {
+    it('should generate unique IDs for different users', () => {
       const id1 = generateTenantId({ ...mockUser, id: 123 });
       const id2 = generateTenantId({ ...mockUser, id: 456 });
       expect(id1).not.toBe(id2);
     });
   });
 
-  describe("createTenant", () => {
-    it("should create a tenant from GitHub user", () => {
+  describe('createTenant', () => {
+    it('should create a tenant from GitHub user', () => {
       const subscription = createFreeSubscription();
       const tenant = createTenant(mockUser, subscription);
 
-      expect(tenant.id).toBe("github-12345");
+      expect(tenant.id).toBe('github-12345');
       expect(tenant.githubUserId).toBe(12345);
-      expect(tenant.githubLogin).toBe("testuser");
-      expect(tenant.type).toBe("user");
+      expect(tenant.githubLogin).toBe('testuser');
+      expect(tenant.type).toBe('user');
       expect(tenant.subscription).toBe(subscription);
       expect(tenant.storageNamespace).toMatch(/^gh-testuser-[a-z0-9]+$/);
       expect(tenant.createdAt).toBeDefined();
@@ -78,77 +78,77 @@ describe("Provisioning", () => {
     });
   });
 
-  describe("validateStorageNamespace", () => {
-    it("should validate valid namespaces", () => {
-      const result = validateStorageNamespace("gh-testuser-abc123");
+  describe('validateStorageNamespace', () => {
+    it('should validate valid namespaces', () => {
+      const result = validateStorageNamespace('gh-testuser-abc123');
       expect(result.valid).toBe(true);
     });
 
-    it("should reject namespaces that are too short", () => {
-      const result = validateStorageNamespace("ab");
+    it('should reject namespaces that are too short', () => {
+      const result = validateStorageNamespace('ab');
       expect(result.valid).toBe(false);
-      expect(result.error).toContain("3-63 characters");
+      expect(result.error).toContain('3-63 characters');
     });
 
-    it("should reject namespaces that are too long", () => {
-      const result = validateStorageNamespace("a".repeat(64));
+    it('should reject namespaces that are too long', () => {
+      const result = validateStorageNamespace('a'.repeat(64));
       expect(result.valid).toBe(false);
-      expect(result.error).toContain("3-63 characters");
+      expect(result.error).toContain('3-63 characters');
     });
 
-    it("should reject namespaces starting with hyphen", () => {
-      const result = validateStorageNamespace("-testuser");
+    it('should reject namespaces starting with hyphen', () => {
+      const result = validateStorageNamespace('-testuser');
       expect(result.valid).toBe(false);
-      expect(result.error).toContain("start with a letter or number");
+      expect(result.error).toContain('start with a letter or number');
     });
 
-    it("should reject namespaces with uppercase letters", () => {
-      const result = validateStorageNamespace("testUser");
+    it('should reject namespaces with uppercase letters', () => {
+      const result = validateStorageNamespace('testUser');
       expect(result.valid).toBe(false);
-      expect(result.error).toContain("lowercase letters");
+      expect(result.error).toContain('lowercase letters');
     });
 
-    it("should reject namespaces with consecutive hyphens", () => {
-      const result = validateStorageNamespace("test--user");
+    it('should reject namespaces with consecutive hyphens', () => {
+      const result = validateStorageNamespace('test--user');
       expect(result.valid).toBe(false);
-      expect(result.error).toContain("consecutive hyphens");
+      expect(result.error).toContain('consecutive hyphens');
     });
 
-    it("should reject namespaces with special characters", () => {
-      const result = validateStorageNamespace("test_user");
+    it('should reject namespaces with special characters', () => {
+      const result = validateStorageNamespace('test_user');
       expect(result.valid).toBe(false);
-      expect(result.error).toContain("lowercase letters, numbers, and hyphens");
+      expect(result.error).toContain('lowercase letters, numbers, and hyphens');
     });
   });
 
-  describe("getAppStorageContainer", () => {
-    it("should generate app storage container name", () => {
-      const container = getAppStorageContainer("gh-testuser-abc", "my-app");
-      expect(container).toBe("gh-testuser-abc-my-app");
+  describe('getAppStorageContainer', () => {
+    it('should generate app storage container name', () => {
+      const container = getAppStorageContainer('gh-testuser-abc', 'my-app');
+      expect(container).toBe('gh-testuser-abc-my-app');
     });
 
-    it("should sanitize app ID", () => {
-      const container = getAppStorageContainer("gh-testuser-abc", "My_App!");
+    it('should sanitize app ID', () => {
+      const container = getAppStorageContainer('gh-testuser-abc', 'My_App!');
       expect(container).toMatch(/^gh-testuser-abc-my-app-?$/);
     });
   });
 
-  describe("provisionTenant", () => {
-    it("should provision a tenant", async () => {
+  describe('provisionTenant', () => {
+    it('should provision a tenant', async () => {
       const subscription = createFreeSubscription();
       const result = await provisionTenant(mockUser, subscription);
 
       expect(result.success).toBe(true);
       expect(result.tenant).toBeDefined();
-      expect(result.tenant?.id).toBe("github-12345");
+      expect(result.tenant?.id).toBe('github-12345');
     });
 
-    it("should validate storage namespace during provisioning", async () => {
+    it('should validate storage namespace during provisioning', async () => {
       // Create a user with invalid characters that would create an invalid namespace
       const invalidUser: GitHubUser = {
         id: 1,
-        login: "a", // Too short after sanitization
-        email: "test@example.com",
+        login: 'a', // Too short after sanitization
+        email: 'test@example.com',
       };
 
       const subscription = createFreeSubscription();

package/src/__tests__/schema.test.ts

@@ -149,7 +149,7 @@ describe('Schema System', () => {
   describe('createSchemaTemplate', () => {
     it('creates a valid schema template', () => {
       const schema = createSchemaTemplate('MyApp');
-      
+
       expect(schema.name).toBe('MyApp');
       expect(schema.version).toBe('1.0.0');
       expect(schema.description).toContain('MyApp');
@@ -176,7 +176,7 @@ describe('Schema System', () => {
       };
 
       const normalized = normalizeSchema(schema);
-      
+
       expect(normalized.models).toHaveLength(1);
       expect(normalized.models[0].fullName).toBe('TestApp.User');
       expect(normalized.models[0].allFields).toHaveLength(2);
@@ -189,9 +189,7 @@ describe('Schema System', () => {
         models: [
           {
             name: 'User',
-            fields: [
-              { name: 'id', type: 'string' },
-            ],
+            fields: [{ name: 'id', type: 'string' }],
           },
         ],
         components: [
@@ -204,7 +202,7 @@ describe('Schema System', () => {
       };
 
       const normalized = normalizeSchema(schema);
-      
+
       expect(normalized.components).toHaveLength(1);
       expect(normalized.components[0].resolvedModel).toBeDefined();
       expect(normalized.components[0].resolvedModel?.name).toBe('User');
@@ -217,9 +215,7 @@ describe('Schema System', () => {
         models: [
           {
             name: 'User',
-            fields: [
-              { name: 'id', type: 'string' },
-            ],
+            fields: [{ name: 'id', type: 'string' }],
           },
           {
             name: 'Task',
@@ -232,8 +228,8 @@ describe('Schema System', () => {
       };
 
       const normalized = normalizeSchema(schema);
-      const taskModel = normalized.models.find(m => m.name === 'Task');
-      
+      const taskModel = normalized.models.find((m) => m.name === 'Task');
+
       expect(taskModel).toBeDefined();
       expect(taskModel?.dependencies).toContain('User');
     });