spex-parser 0.1.5 → 0.6.2

package/tests/parser.test.ts

@@ -96,6 +96,13 @@ describe('SpexParser', () => {
       expect(parser.errors).toHaveLength(0)
     })
 
+    it('should parse subobject declaration with a set operation base', () => {
+      const testCase =
+        'create MySubobject as from Web intersect TypeScript select { is an express app };'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
     it('should parse array type declaration', () => {
       const testCase = 'create MyArray as string[];'
       const { parser } = parseInput(testCase)
@@ -145,6 +152,18 @@ describe('SpexParser', () => {
       expect(parser.errors).toHaveLength(0)
     })
 
+    it('should parse basic object concept', () => {
+      const testCase = 'create MyObject as concept;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse basic object environment', () => {
+      const testCase = 'create MyObject as environment;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
     it('should parse basic objects in product fields', () => {
       const testCase = 'create Config as (name: string, count: number, active: bool);'
       const { parser } = parseInput(testCase)
@@ -174,6 +193,18 @@ describe('SpexParser', () => {
       const { parser } = parseInput(testCase)
       expect(parser.errors).not.toHaveLength(0)
     })
+
+    it('should not allow overriding basic object concept', () => {
+      const testCase = 'create concept as Number;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
+
+    it('should not allow overriding basic object environment', () => {
+      const testCase = 'create environment as Number;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
   })
 
   describe('import declaration', () => {
@@ -212,64 +243,343 @@ describe('SpexParser', () => {
     })
   })
 
+  describe('enum object', () => {
+    it('should parse enum object declaration', () => {
+      const testCase = "create myEnum as enum ('v1', 'v2');"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse enum object declaration case-insensitively', () => {
+      const testCase = "CREATE myEnum AS ENUM ('v1', 'v2');"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse single-value enum object', () => {
+      const testCase = "create Status as enum ('ACTIVE');"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse enum object with double quoted values', () => {
+      const testCase = 'create myEnum as enum ("v1", "v2");'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse enum object with mixed quote values', () => {
+      const testCase = "create myEnum as enum (\"v1\", 'v2');"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse enum object with escaped values', () => {
+      const testCase = "create myEnum as enum ('it\\'s');"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse enum object inside a product object', () => {
+      const testCase = "create Config as (kind: enum ('a', 'b'));"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse array of enum object', () => {
+      const testCase = "create myEnum as enum ('a', 'b')[];"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should not parse enum object without values', () => {
+      const testCase = 'create myEnum as enum ();'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
+
+    it('should not parse enum object with a trailing comma', () => {
+      const testCase = "create myEnum as enum ('v1',);"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
+
+    it('should not parse enum object without parentheses', () => {
+      const testCase = 'create myEnum as enum;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
+  })
+
+  describe('literal object', () => {
+    it('should parse string literal object', () => {
+      const testCase = 'create Foo as "SpexFile";'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse number literal object', () => {
+      const testCase = 'create Foo as 42;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse bool literal object', () => {
+      const testCase = 'create Foo as true;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse product of literal objects', () => {
+      const testCase = "create Foo as (name: \"John\", age: 42);"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse exponential of literal objects', () => {
+      const testCase = 'create Foo as "a" -> "b";'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should not parse literal with member suffix', () => {
+      const testCase = 'create Foo as "a".b;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
+  })
+
+  describe('set object', () => {
+    it('should parse union object', () => {
+      const testCase = 'create X as A UNION B;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse intersect object', () => {
+      const testCase = 'create X as A INTERSECT B;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse except object', () => {
+      const testCase = 'create X as A EXCEPT B;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse chained set operations', () => {
+      const testCase = 'create X as A UNION B INTERSECT C;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse set operations on subobjects', () => {
+      const testCase =
+        'create X as from int select { are even } UNION from int select { are positive };'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse set operations with literals', () => {
+      const testCase = 'create X as string EXCEPT "root";'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse set operations in product fields', () => {
+      const testCase = 'create X as (a: A UNION B);'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse case-insensitively', () => {
+      const testCase = 'CREATE X AS A union B;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should bind arrow tighter than set operations', () => {
+      const testCase = 'create X as A -> B UNION C;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+  })
+
+  describe('coproduct object', () => {
+    it('should parse a pipe object', () => {
+      const testCase = 'create Shape as Point | Circle;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse chained pipes left-associatively', () => {
+      const testCase = 'create X as A | B | C;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should bind arrow tighter than pipe', () => {
+      const testCase = 'create X as A -> B | C;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should bind pipe tighter than set operations', () => {
+      const testCase = 'create X as A UNION B | C;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse pipes in product fields', () => {
+      const testCase = 'create X as (a: A | B, b: C);'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse pipes on subobjects', () => {
+      const testCase =
+        'create X as from int select { are even } | from int select { are odd };'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse pipes with literals', () => {
+      const testCase = 'create X as string | "number";'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+  })
+
+  describe('parenthesized object', () => {
+    it('should parse a parenthesized coproduct', () => {
+      const testCase = 'create X as (A | B);'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should override precedence with parentheses', () => {
+      const testCase = 'create X as A -> (B | C);'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should group set operations with parentheses', () => {
+      const testCase = 'create X as (A UNION B) EXCEPT C;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse nested parentheses', () => {
+      const testCase = 'create X as ((A | B));'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse arrays of parenthesized objects', () => {
+      const testCase = 'create X as (A | B)[];'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should still parse products inside parentheses', () => {
+      const testCase = 'create X as (a: (B | C));'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+  })
+
+  describe('pattern object', () => {
+    it('should parse a pattern object', () => {
+      const testCase = 'create X as /\\d+/;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse a pattern object with flags', () => {
+      const testCase = 'create X as /create\\b/i;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse patterns in product fields', () => {
+      const testCase = 'create X as (name: string, pattern: /[a-z]+/i);'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse patterns in set operations', () => {
+      const testCase = 'create X as /\\d+/ UNION /\\w+/;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+  })
+
   describe('package declaration', () => {
     it('should parse package executable declaration', () => {
-      const testCase = 'package executable myapp as Main;'
+      const testCase = 'package executable myapp as Main in Python;'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
 
     it('should parse package module declaration', () => {
-      const testCase = 'package module mylib as utils;'
+      const testCase = 'package module mylib as utils in Node;'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
 
     it('should parse package executable with exponential object', () => {
-      const testCase = 'package executable cli as (path: string) -> unit;'
+      const testCase = 'package executable cli as (path: string) -> unit in Python;'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
 
     it('should parse package executable with dotted name', () => {
-      const testCase = 'package executable myapp as app.Main;'
+      const testCase = 'package executable myapp as app.Main in Python;'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
 
     it('should parse package module with array type', () => {
-      const testCase = 'package module mylib as string[];'
+      const testCase = 'package module mylib as string[] in Python;'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
 
     it('should parse package executable with product type', () => {
-      const testCase = 'package module mylib as (name: string, count: number);'
+      const testCase = 'package module mylib as (name: string, count: number) in Python;'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
 
     it('should parse package executable with subobject', () => {
-      const testCase = 'package executable myapp as from string select { is a valid command };'
+      const testCase =
+        'package executable myapp as from string select { is a valid command } in Python;'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
 
     it('should parse package declaration case-insensitively', () => {
-      const testCase = 'PACKAGE EXECUTABLE myapp AS Main;'
+      const testCase = 'PACKAGE EXECUTABLE myapp AS Main IN Python;'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
 
     it('should parse mixed package and generate declarations', () => {
-      const testCase = 'package executable myapp as Main;\ngenerate Main;'
+      const testCase = 'package executable myapp as Main in Python;\ngenerate Main;'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
 
     it('should parse package declaration with complex nested type', () => {
       const testCase =
-        'package module mylib as from (x: number, y: number) -> number select { computes distance };'
+        'package module mylib as from (x: number, y: number) -> number select { computes distance } in Node;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse package with complex environment object', () => {
+      const testCase = 'package executable myapp as Main in from environment select { python };'
       const { parser } = parseInput(testCase)
       expect(parser.errors).toHaveLength(0)
     })
@@ -338,4 +648,139 @@ describe('SpexParser', () => {
       expect(parser.errors).toHaveLength(0)
     })
   })
+
+  describe('realize declaration', () => {
+    it('should parse a realize declaration', () => {
+      const testCase = 'realize Shape as Circle in environment;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse a realize declaration case-insensitively', () => {
+      const testCase = 'REALIZE Shape AS Circle IN environment;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse a realize declaration with product objects', () => {
+      const testCase = 'realize (x: number) as (y: string) in environment;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse a realize declaration with exponential objects', () => {
+      const testCase = 'realize string -> number as string -> string in environment;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse a realize declaration with a named environment', () => {
+      const testCase = 'realize A as B in MyEnv;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse a realize declaration without an environment', () => {
+      const testCase = 'realize A as B;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse a realize declaration mixed with other declarations', () => {
+      const testCase = 'create A as string;\nrealize A as B in MyEnv;\ngenerate A;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+  })
+
+  describe('include declaration', () => {
+    it('should parse include declaration', () => {
+      const testCase = 'include "config.json" as config;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse include declaration case-insensitively', () => {
+      const testCase = 'INCLUDE "config.json" AS config;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse include with single-quoted address', () => {
+      const testCase = "include 'data/file.txt' as myfile;"
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse include with folder address', () => {
+      const testCase = 'include "images/" as assets;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse include mixed with other declarations', () => {
+      const testCase =
+        'include "config.json" as config;\ncreate Todo as (id: string);\ngenerate Main;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should not parse include without address', () => {
+      const testCase = 'include as config;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
+
+    it('should not parse include without name', () => {
+      const testCase = 'include "config.json" as ;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
+  })
+
+  describe('lambda object', () => {
+    it('should parse lambda with product base', () => {
+      const testCase = 'create sum as lambda (a: number, b: number) -> number ```python\nreturn a + b\n```;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse lambda with named base', () => {
+      const testCase = 'create double as lambda number -> number ```python\nreturn @n * 2\n```;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse lambda case-insensitively', () => {
+      const testCase = 'create sum as LAMBDA (a: number) -> number ```python\nreturn @a\n```;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse lambda with pattern blocks', () => {
+      const testCase =
+        'create transform as lambda (x: number) -> number ```python\nif @x > 0:\n  @{return sin(@x)}\nelse:\n  @{return cos(@x)}\n```;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should parse lambda in product field', () => {
+      const testCase =
+        'create Config as (handler: lambda (x: string) -> string ```typescript\nreturn x.toUpperCase();\n```, port: number);'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).toHaveLength(0)
+    })
+
+    it('should not parse lambda without language', () => {
+      const testCase = 'create sum as lambda (a: number) -> number ```\nreturn @a\n```;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
+
+    it('should not parse lambda without code block', () => {
+      const testCase = 'create sum as lambda (a: number) -> number;'
+      const { parser } = parseInput(testCase)
+      expect(parser.errors).not.toHaveLength(0)
+    })
+  })
 })

package/tests/props/express_todo_web.spex

@@ -0,0 +1,108 @@
+-- The Express realization of the Todo Web app.
+--
+-- Imports the shared TodoWeb representation, the todo operations, and the
+-- Express environment. PostgreSQL storage, the route handlers, and the main
+-- exponential are defined as separate objects, and the concept is realized
+-- as a product of them in the realize statement. Express handlers receive a
+-- request and a response and write to the response.
+
+import TodoWeb from "todo.spex";
+import Todo from "todo.spex";
+import TodoId from "todo.spex";
+import TodoTitle from "todo.spex";
+import AddTodo from "todo.spex";
+import ListTodos from "todo.spex";
+import CompleteTodo from "todo.spex";
+import HttpRequest from "todo.spex";
+import HttpResponse from "todo.spex";
+import ExpressWebEnv from "express_web_env.spex";
+
+-- TODO: realize the shared HttpRequest and HttpResponse objects using the
+-- types provided by the express dependency in ExpressWebEnv.
+
+/* PostgreSQL storage. */
+create PgPool as (
+  connectionString: string
+);
+
+create ConnectPostgres as
+from (connectionString: string) -> PgPool
+select {
+  1. create a connection pool to the PostgreSQL database
+  2. create the todos table if it does not exist
+};
+
+create SelectTodos as
+from (pool: PgPool) -> Todo[]
+select {
+  1. query the id, title, and completed columns from the todos table
+  2. map each row to a @Todo
+};
+
+create InsertTodo as
+from (pool: PgPool, todo: Todo) -> unit
+select {
+  1. insert the id, title, and completed values of @todo into the todos table
+};
+
+create UpdateTodo as
+from (pool: PgPool, todo: Todo) -> unit
+select {
+  1. update the completed value of the row matching the id of @todo
+};
+
+/* Route handlers. */
+create ListTodosHandler as
+from (request: HttpRequest, response: HttpResponse) -> unit
+select {
+  1. query the todos with @SelectTodos
+  2. write the todos serialized as JSON to @response with status 200
+};
+
+create AddTodoHandler as
+from (request: HttpRequest, response: HttpResponse) -> unit
+select {
+  1. parse the JSON body of @request into a @TodoTitle
+  2. create the todo with @AddTodo
+  3. persist the todo with @InsertTodo
+  4. write the created todo serialized as JSON to @response with status 201
+};
+
+create CompleteTodoHandler as
+from (request: HttpRequest, response: HttpResponse) -> unit
+select {
+  1. extract the todo id from the path of @request
+  2. load the todos with @SelectTodos
+  3. find the matching @Todo and complete it with @CompleteTodo
+  4. persist it with @UpdateTodo
+  5. write the updated todo serialized as JSON to @response with status 200
+};
+
+/* The main entry exponential. */
+create ExpressTodoWeb as
+from unit -> unit
+select {
+  1. create the express app object
+  2. add the JSON body parser middleware
+  3. mount @ListTodosHandler on the GET /todos route
+  4. mount @AddTodoHandler on the POST /todos route
+  5. mount @CompleteTodoHandler on the PATCH /todos/:id route
+  6. connect to PostgreSQL
+  7. listen on the configured port
+};
+
+realize TodoWeb as (
+  list: ListTodosHandler,
+  add: AddTodoHandler,
+  complete: CompleteTodoHandler,
+  storage: (
+    connect: ConnectPostgres,
+    query: SelectTodos,
+    insert: InsertTodo,
+    update: UpdateTodo
+  ),
+  main: ExpressTodoWeb
+) in ExpressWebEnv;
+
+generate ExpressTodoWeb;
+package executable expresstodo as ExpressTodoWeb in ExpressWebEnv;

package/tests/props/express_web_env.spex

@@ -0,0 +1,16 @@
+-- The Express web environment.
+--
+-- A subobject of the shared Web environment intersected with the shared
+-- TypeScript environment.
+
+import Web from "todo.spex";
+import TypeScript from "todo.spex";
+
+create ExpressWebEnv as
+from Web intersect TypeScript
+select {
+  dependencies: express,
+  database: PostgreSQL
+};
+
+export ExpressWebEnv;