rado 0.1.16 → 0.1.18

package/dist/lib/Formatter.js

@@ -80,22 +80,22 @@ var Formatter = class {
     }
   }
   formatSelect(query, ctx) {
-    return raw("select").add(this.formatSelection(query.selection, ctx)).addLine("from").add(this.formatTarget(query.from, ctx)).add(this.formatWhere(query.where, ctx)).add(this.formatGroupBy(query.groupBy, ctx)).add(this.formatHaving(query.having, ctx)).add(this.formatOrderBy(query.orderBy, ctx)).add(this.formatLimit(query, ctx));
+    return raw("SELECT").add(this.formatSelection(query.selection, ctx)).addLine("FROM").add(this.formatTarget(query.from, ctx)).add(this.formatWhere(query.where, ctx)).add(this.formatGroupBy(query.groupBy, ctx)).add(this.formatHaving(query.having, ctx)).add(this.formatOrderBy(query.orderBy, ctx)).add(this.formatLimit(query, ctx));
   }
   formatInsert(query, ctx) {
     const columns = Object.values(query.into.columns);
-    return raw("insert into").addIdentifier(query.into.name).addIf(query.into.alias, () => raw("as").addIdentifier(query.into.alias)).parenthesis(
+    return raw("INSERT INTO").addIdentifier(query.into.name).addIf(query.into.alias, () => raw("AS").addIdentifier(query.into.alias)).parenthesis(
       separated(columns.map((column) => this.formatString(column.name)))
-    ).add("values").addSeparated(
+    ).add("VALUES").addSeparated(
       query.data.map((row) => this.formatInsertRow(query.into.columns, row))
     ).addIf(
       query.selection,
-      () => raw("returning").add(this.formatSelection(query.selection, ctx))
+      () => raw("RETURNING").add(this.formatSelection(query.selection, ctx))
     );
   }
   formatUpdate(query, ctx) {
     const data = query.set || {};
-    return raw("update").addIdentifier(query.table.name).add("set").addSeparated(
+    return raw("UPDATE").addIdentifier(query.table.name).add("SET").addSeparated(
       Object.keys(data).map((key) => {
         const column = query.table.columns[key];
         const exprData = data[key];
@@ -109,10 +109,10 @@ var Formatter = class {
     ).add(this.formatWhere(query.where, ctx)).add(this.formatLimit(query, ctx));
   }
   formatDelete(query, ctx) {
-    return raw("delete from").addIdentifier(query.table.name).add(this.formatWhere(query.where, ctx)).add(this.formatLimit(query, ctx));
+    return raw("DELETE FROM").addIdentifier(query.table.name).add(this.formatWhere(query.where, ctx)).add(this.formatLimit(query, ctx));
   }
   formatCreateTable(query, ctx) {
-    return raw("create table").addIf(query.ifNotExists, "if not exists").addCall(
+    return raw("CREATE TABLE").addIf(query.ifNotExists, "IF NOT EXISTS").addCall(
       query.table.name,
       ...Object.values(query.table.columns).map((column) => {
         return this.formatColumn(column);
@@ -120,7 +120,7 @@ var Formatter = class {
     );
   }
   formatCreateIndex(query, ctx = {}) {
-    return raw("create").addIf(query.index.unique, "unique").add("index").addIf(query.ifNotExists, "if not exists").addIdentifier(query.index.name).add("on").addIdentifier(query.table.name).parenthesis(
+    return raw("CREATE").addIf(query.index.unique, "UNIQUE").add("INDEX").addIf(query.ifNotExists, "IF NOT EXISTS").addIdentifier(query.index.name).add("ON").addIdentifier(query.table.name).parenthesis(
       separated(
         query.index.on.map(
           (expr) => this.formatExprValue(expr, {
@@ -133,14 +133,14 @@ var Formatter = class {
     ).add(this.formatWhere(query.where, ctx));
   }
   formatDropIndex(query, ctx) {
-    return raw("drop index").addIf(query.ifExists, "if exists").addIdentifier(query.name);
+    return raw("DROP INDEX").addIf(query.ifExists, "IF EXISTS").addIdentifier(query.name);
   }
   formatAlterTable(query, ctx) {
-    let stmt = raw("alter table").addIdentifier(query.table.name);
+    let stmt = raw("ALTER TABLE").addIdentifier(query.table.name);
     if (query.addColumn) {
-      stmt = stmt.add("add column").add(this.formatColumn(query.addColumn));
+      stmt = stmt.add("ADD COLUMN").add(this.formatColumn(query.addColumn));
     } else if (query.dropColumn) {
-      stmt = stmt.add("drop column").addIdentifier(query.dropColumn);
+      stmt = stmt.add("DROP COLUMN").addIdentifier(query.dropColumn);
     } else if (query.alterColumn) {
       throw new Error(`Not available in this formatter: alter column`);
     }
@@ -149,11 +149,11 @@ var Formatter = class {
   formatTransaction({ op, id }, ctx) {
     switch (op) {
       case Query.TransactionOperation.Begin:
-        return raw("savepoint").addIdentifier(id);
+        return raw("SAVEPOINT").addIdentifier(id);
       case Query.TransactionOperation.Commit:
-        return raw("release").addIdentifier(id);
+        return raw("RELEASE").addIdentifier(id);
       case Query.TransactionOperation.Rollback:
-        return raw("rollback to").addIdentifier(id);
+        return raw("ROLLBACK TO").addIdentifier(id);
     }
   }
   formatBatch(queries, ctx) {
@@ -166,9 +166,9 @@ var Formatter = class {
     return Statement.tag(strings, ...params);
   }
   formatColumn(column) {
-    return identifier(column.name).add(this.formatType(column.type)).addIf(column.unique, "unique").addIf(column.autoIncrement, "autoincrement").addIf(column.primaryKey, "primary key").addIf(!column.nullable, "not null").addIf(
+    return identifier(column.name).add(this.formatType(column.type)).addIf(column.unique, "UNIQUE").addIf(column.autoIncrement, "AUTOINCREMENT").addIf(column.primaryKey, "PRIMARY KEY").addIf(!column.nullable, "NOT NULL").addIf(
       column.defaultValue !== void 0,
-      raw("default").add(this.formatInlineValue(column.defaultValue))
+      raw("DEFAULT").add(this.formatInlineValue(column.defaultValue))
     ).addIf(column.references, () => {
       return this.formatContraintReference(column.references);
     });
@@ -177,20 +177,20 @@ var Formatter = class {
     if (reference.type !== ExprType.Field || reference.expr.type !== ExprType.Row)
       throw new Error("not supported");
     const from = reference.expr.target;
-    return raw("references").addIdentifier(Target.source(from).name).parenthesis(identifier(reference.field));
+    return raw("REFERENCES").addIdentifier(Target.source(from).name).parenthesis(identifier(reference.field));
   }
   formatType(type) {
     switch (type) {
       case ColumnType.String:
-        return raw("text");
+        return raw("TEXT");
       case ColumnType.Json:
-        return raw("json");
+        return raw("JSON");
       case ColumnType.Number:
-        return raw("numeric");
+        return raw("NUMERIC");
       case ColumnType.Boolean:
-        return raw("boolean");
+        return raw("BOOLEAN");
       case ColumnType.Integer:
-        return raw("integer");
+        return raw("INTEGER");
     }
   }
   formatInsertRow(columns, row) {
@@ -209,7 +209,7 @@ var Formatter = class {
     if (isNull) {
       if (!isOptional)
         throw new TypeError(`Expected value for column ${column.name}`);
-      return raw("null");
+      return raw("NULL");
     }
     switch (column.type) {
       case ColumnType.String:
@@ -236,11 +236,11 @@ var Formatter = class {
       case TargetType.Table:
         return identifier(target.table.name).addIf(
           target.table.alias,
-          () => raw("as").addIdentifier(target.table.alias)
+          () => raw("AS").addIdentifier(target.table.alias)
         );
       case TargetType.Join:
         const { left, right, joinType } = target;
-        return this.formatTarget(left, ctx).addLine(joins[joinType]).add("join").add(this.formatTarget(right, ctx)).add("on").add(this.formatExprValue(target.on, ctx));
+        return this.formatTarget(left, ctx).addLine(joins[joinType]).add("JOIN").add(this.formatTarget(right, ctx)).add("ON").add(this.formatExprValue(target.on, ctx));
       default:
         throw new Error(`Cannot format target of type ${target.type}`);
     }
@@ -248,25 +248,25 @@ var Formatter = class {
   formatWhere(expr, ctx) {
     if (!expr)
       return;
-    return newline().raw("where").add(this.formatExprValue(expr, ctx));
+    return newline().raw("WHERE").add(this.formatExprValue(expr, ctx));
   }
   formatHaving(expr, ctx) {
     if (!expr)
       return;
-    return newline().raw("having").add(this.formatExprValue(expr, ctx));
+    return newline().raw("HAVING").add(this.formatExprValue(expr, ctx));
   }
   formatGroupBy(groupBy, ctx) {
     if (!groupBy)
       return;
-    return newline().raw("group by").addSeparated(groupBy.map((expr) => this.formatExprValue(expr, ctx)));
+    return newline().raw("GROUP BY").addSeparated(groupBy.map((expr) => this.formatExprValue(expr, ctx)));
   }
   formatOrderBy(orderBy, ctx) {
     if (!orderBy)
       return;
-    return newline().raw("order by").addSeparated(
+    return newline().raw("ORDER BY").addSeparated(
       orderBy.map(
         ({ expr, order }) => this.formatExprValue(expr, ctx).add(
-          order === OrderDirection.Asc ? "asc" : "desc"
+          order === OrderDirection.Asc ? "ASC" : "DESC"
         )
       )
     );
@@ -274,7 +274,7 @@ var Formatter = class {
   formatLimit({ limit, offset, singleResult }, ctx) {
     if (!limit && !offset && !singleResult)
       return;
-    return newline().raw("limit").addValue(singleResult ? 1 : limit).addIf(offset && offset > 0, raw("offset").addValue(offset));
+    return newline().raw("LIMIT").addValue(singleResult ? 1 : limit).addIf(offset && offset > 0, raw("OFFSET").addValue(offset));
   }
   formatSelection(selection, ctx) {
     const { formatSubject } = ctx;
@@ -285,7 +285,7 @@ var Formatter = class {
     });
     return (formatSubject ? formatSubject(subject) : subject).addIf(
       ctx.nameResult,
-      raw("as").addIdentifier(ctx.nameResult)
+      raw("AS").addIdentifier(ctx.nameResult)
     );
   }
   formatExprValue(expr, ctx) {
@@ -300,7 +300,7 @@ var Formatter = class {
     }
   }
   formatUnwrapArray(stmt) {
-    return parenthesis(raw("select value from").addCall("json_each", stmt));
+    return parenthesis(raw("SELECT value FROM").addCall("json_each", stmt));
   }
   retrieveField(expr, field) {
     switch (expr.type) {
@@ -324,14 +324,15 @@ var Formatter = class {
             const column = expr.target.table.columns[field];
             switch (column?.type) {
               case ColumnType.Json:
-                return call("json", selection);
+                if (ctx.formatAsJson)
+                  return call("json", selection);
               default:
                 return selection;
             }
         }
       default:
         return this.formatAccess(
-          this.formatExpr(expr, { ...ctx, formatAsJson: true }),
+          this.formatExpr(expr, ctx),
           field,
           ctx.formatAsJson
         );
@@ -343,9 +344,9 @@ var Formatter = class {
   formatInlineValue(rawValue) {
     switch (true) {
       case (rawValue === null || rawValue === void 0):
-        return raw("null");
+        return raw("NULL");
       case typeof rawValue === "boolean":
-        return rawValue ? raw("true") : raw("false");
+        return rawValue ? raw("TRUE") : raw("FALSE");
       case (typeof rawValue === "string" || typeof rawValue === "number"):
         return this.formatString(rawValue);
       default:
@@ -356,7 +357,7 @@ var Formatter = class {
     const { formatAsJson, forceInline } = ctx;
     switch (true) {
       case (rawValue === null || rawValue === void 0):
-        return raw("null");
+        return raw("NULL");
       case (!formatAsJson && typeof rawValue === "boolean"):
         return rawValue ? raw("1") : raw("0");
       case Array.isArray(rawValue):
@@ -384,9 +385,9 @@ var Formatter = class {
       case ExprType.UnOp:
         switch (expr.op) {
           case UnOp.IsNull:
-            return this.formatExprValue(expr.expr, ctx).add("is null");
+            return this.formatExprValue(expr.expr, ctx).add("IS NULL");
           case UnOp.Not:
-            return raw("not").addParenthesis(
+            return raw("NOT").addParenthesis(
               this.formatExprValue(expr.expr, ctx)
             );
         }
@@ -426,7 +427,7 @@ var Formatter = class {
         if (expr.query.singleResult)
           return call("json", parenthesis(subQuery));
         return parenthesis(
-          raw("select json_group_array(json(result))").newline().raw("from ").parenthesis(subQuery)
+          raw("SELECT json_group_array(json(result))").newline().raw("FROM").addParenthesis(subQuery)
         );
       case ExprType.Row:
         switch (expr.target.type) {
@@ -468,11 +469,11 @@ var Formatter = class {
         switch (target.type) {
           case TargetType.Each:
             return parenthesis(
-              raw("select json_group_array(json(result)) from").addParenthesis(
-                raw("select value as result").add("from").addCall(
+              raw("SELECT json_group_array(json(result)) FROM").addParenthesis(
+                raw("SELECT value AS result").add("FROM").addCall(
                   "json_each",
                   this.formatExpr(target.expr, { ...ctx, formatAsJson: true })
-                ).add("as").addIdentifier(target.alias).add("where").add(this.formatExprValue(condition, ctx))
+                ).add("AS").addIdentifier(target.alias).add("WHERE").add(this.formatExprValue(condition, ctx))
               )
             );
           default:
@@ -484,11 +485,11 @@ var Formatter = class {
         switch (target.type) {
           case TargetType.Each:
             return parenthesis(
-              raw("select json_group_array(json(result)) from").addParenthesis(
-                raw("select").add(this.formatExpr(result, { ...ctx, formatAsJson: true })).add("as").addIdentifier("result").add("from").addCall(
+              raw("SELECT json_group_array(json(result)) FROM").addParenthesis(
+                raw("SELECT").add(this.formatExpr(result, { ...ctx, formatAsJson: true })).add("AS").addIdentifier("result").add("FROM").addCall(
                   "json_each",
                   this.formatExpr(target.expr, { ...ctx, formatAsJson: true })
-                ).add("as").addIdentifier(target.alias)
+                ).add("AS").addIdentifier(target.alias)
               )
             );
           default:

package/dist/sqlite/SqliteFormatter.js

@@ -49,7 +49,7 @@ var SqliteFormatter = class extends Formatter {
             throw new Error("not implemented");
           if (from.target.type !== TargetType.Table)
             throw new Error("not implemented");
-          return identifier(from.target.table.alias || from.target.table.name).raw(" match ").concat(this.formatExprValue(query, ctx));
+          return identifier(from.target.table.alias || from.target.table.name).raw(" MATCH ").concat(this.formatExprValue(query, ctx));
         }
       default:
         return super.formatExpr(expr, ctx);

package/dist/sqlite/SqliteSchema.js

@@ -26,9 +26,9 @@ var SqliteSchema;
   function columnInstruction(column) {
     return [
       column.name,
-      identifier(column.name).add(column.type.toLowerCase()).addIf(column.pk === 1, "primary key").addIf(column.notnull === 1, "not null").addIf(
+      identifier(column.name).add(column.type).addIf(column.pk === 1, "PRIMARY KEY").addIf(column.notnull === 1, "NOT NULL").addIf(
         column.dflt_value !== null,
-        raw("default").add(column.dflt_value)
+        raw("DEFAULT").add(column.dflt_value)
       ).compile(formatter)[0]
     ];
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "license": "MIT",
   "type": "module",
   "exports": {