Loony ·

Loony is a proof-of-concept library for building Javascript DSLs.

First you define your language using nearley. Then you write programs with method chaining and recursive tagged template calls.

Compiled programs either produce an output or throw an error if you've written an invalid program.

Example

The following is an example of a SQL DSL built with Loony.

const sql = require('loony')( ... )

sql.select`title``genre`.from`book`.where`id = 7`.query
// "select title, genre from book where id = 7"

sql.delete.from`book`.where`genre = 'Fiction'`.query
// "delete  from book where genre = 'Fiction'"

sql.insert.into`book`.values`title = '1984'`.query
// "insert into book values title = '1984'"

sql.update`book`.set`title = '1984'`.query
// "update book set title = '1984'"

sql.select.from`title``genre`.from`book`.where`id = 7`.query
// throws error blaming .from

sql.select`title`.from`book``author`.where`id = 7`.query
// throws error blaming `author`

sql was defined as:

const sql = require('loony')({
  // grammar generatd with nearely: https://github.com/kach/nearley
  grammar: require('./sql.js'),
  // language keywords
  keywords: [
    'select',
    'from',
    'where',
    'delete',
    'insert',
    'into',
    'values',
    'update',
    'set'
  ],
  // add custom properties to builder
  properties: {
    // make .query an alias for ._compile()
    query: {
      get: function() {
        return this._compile()
      }
    }
  }
})

sql.js was generated from the nearley grammar file sql.ne:

@{%
const select = { literal: 'select' };
const from = { literal: 'from' };
const where = { literal: 'where' };
const del = { literal: 'delete' };
const insert = { literal: 'insert' };
const into = { literal: 'into' };
const values = { literal: 'values' };
const update = { literal: 'update' };
const set = { literal: 'set' };
const t = { test: x => Array.isArray(x) };
%}

sql    -> select                      {% id %}
       |  delete                      {% id %}
       |  insert                      {% id %}
       |  update                      {% id %}
select -> %select %t:+ from:? where:? {% d => 'select ' + d[1].join(', ') + (d[2] || '') + (d[3] || '') %}
from   -> %from %t                    {% d => ' from ' + d[1] %}
where  -> %where %t                   {% d => ' where '+ d[1] %}
delete -> %del from where:?           {% d => 'delete ' + d[1] + (d[2] || '') %}
insert -> %insert %into %t values     {% d => 'insert into ' + d[2] + d[3] %}
values -> %values %t:+                {% d => ' values ' + d[1].join(', ') %}
update -> %update %t set              {% d => 'update ' + d[1] + d[2] %}
set    -> %set %t:+                   {% d => ' set ' + d[1].join(', ') %}

Future

loony is a proof of concept. There are many ways it can be improved. Feel free to submit PRs.

License

MIT Licensed, Copyright (c) 2018 Sufyan Dawoodjee