json-fs-query 1.1.0 → 2.0.0

package/dist/data/utilities/parsers/parseCreate.js

@@ -0,0 +1,330 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseCreate = exports.createMatch = void 0;
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.find.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.iterator.some.js");
+require("core-js/modules/esnext.set.add-all.js");
+require("core-js/modules/esnext.set.delete-all.js");
+require("core-js/modules/esnext.set.difference.js");
+require("core-js/modules/esnext.set.every.js");
+require("core-js/modules/esnext.set.filter.js");
+require("core-js/modules/esnext.set.find.js");
+require("core-js/modules/esnext.set.intersection.js");
+require("core-js/modules/esnext.set.is-disjoint-from.js");
+require("core-js/modules/esnext.set.is-subset-of.js");
+require("core-js/modules/esnext.set.is-superset-of.js");
+require("core-js/modules/esnext.set.join.js");
+require("core-js/modules/esnext.set.map.js");
+require("core-js/modules/esnext.set.reduce.js");
+require("core-js/modules/esnext.set.some.js");
+require("core-js/modules/esnext.set.symmetric-difference.js");
+require("core-js/modules/esnext.set.union.js");
+var _typeCheck = require("../../introspect/policies/typeCheck");
+var _maskStrings = require("./maskStrings");
+var _startsQuery = require("./startsQuery");
+const createMatch = exports.createMatch = /^\s*create(?![a-z0-9_-])/i;
+const headMatch = /^\s*create\s+(if\s+not\s+exists\s+)?([a-z0-9_-]+)\s*\(/i;
+const nameSource = '[a-z0-9_-]+';
+const nameMatch = new RegExp(`^${nameSource}$`, 'i');
+const fieldMatch = new RegExp(`^(${nameSource})\\s+(${nameSource})((?:\\s[\\s\\S]*)?)$`, 'i');
+const primaryMatch = /^primary\s+key\s*\(([^()]*)\)$/i;
+const uniqueMatch = /^unique\s*\(([^()]*)\)$/i;
+const indexMatch = /^index\s*\(([^()]*)\)$/i;
+const foreignMatch = new RegExp(`^foreign\\s+key\\s*\\(([^()]*)\\)\\s*references\\s+(${nameSource})\\s*\\(([^()]*)\\)$`, 'i');
+const stringLiteral = new RegExp(`^${_maskStrings.placeholderSource}$`);
+const arrayLiteral = new RegExp(`^${_maskStrings.arraySource}$`);
+const lookupPrefix = {
+  primary: 'pk',
+  unique: 'unique',
+  index: 'index',
+  foreign: 'fk'
+};
+/**
+ * Show a piece of the (masked) query the way it was written, for an error message.
+ * @param text
+ */
+const shown = text => (0, _maskStrings.unmaskStrings)(text.trim(), '\'');
+/**
+ * The position of the `)` closing the `(` at `open`, or -1. Strings and arrays are placeholders by now, so round
+ * brackets are the only nesting left.
+ * @param text
+ * @param open
+ */
+const findClose = (text, open) => {
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    if (text[i] === '(') {
+      depth++;
+    } else if (text[i] === ')') {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+};
+/**
+ * Split the text inside the brackets on the commas that are not inside a key's own brackets.
+ * @param body
+ */
+const splitItems = body => {
+  const items = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] === '(') {
+      depth++;
+    } else if (body[i] === ')') {
+      depth--;
+    } else if (body[i] === ',' && depth === 0) {
+      items.push(body.slice(start, i));
+      start = i + 1;
+    }
+  }
+  items.push(body.slice(start));
+  return items.map(item => item.trim());
+};
+/**
+ * The names in a key's brackets: `(a, b)` gives ['a', 'b'].
+ * @param list
+ * @param item - The whole key, for the error message.
+ */
+const parseNames = (list, item) => {
+  const names = list.split(',').map(name => name.trim());
+  if (names.some(name => !nameMatch.test(name))) {
+    throw new Error(`Expected field names separated by commas in: ${shown(item)}`);
+  }
+  if (new Set(names).size !== names.length) {
+    throw new Error(`The same field is named twice in: ${shown(item)}`);
+  }
+  return names;
+};
+/**
+ * A default's value: the same literals the rest of the query language reads.
+ * @param token
+ */
+const parseDefault = token => {
+  if (typeof token === 'undefined') {
+    throw new Error('Missing a value after default');
+  }
+  const string = token.match(stringLiteral);
+  if (string) {
+    return (0, _maskStrings.fromPlaceholder)(string[1]);
+  }
+  const array = token.match(arrayLiteral);
+  if (array) {
+    return JSON.parse((0, _maskStrings.fromPlaceholder)(array[1]));
+  }
+  if (/^[0-9]+$/.test(token)) {
+    return Number(token);
+  }
+  switch (token.toLowerCase()) {
+    case 'null':
+      return null;
+    case 'true':
+      return true;
+    case 'false':
+      return false;
+  }
+  throw new Error(`Unrecognized default value: ${shown(token)}`);
+};
+/**
+ * One field: `<name> <type> [optional] [null | not null] [auto] [default <value>]`, the modifiers in any order.
+ * @param found - The field's fieldMatch match.
+ */
+const parseField = found => {
+  const [item, name, typeName, rest] = found;
+  const type = typeName.toLowerCase();
+  if (!_typeCheck.fieldTypes.includes(type)) {
+    throw new Error(`Unknown type "${typeName}" for field "${name}" (expected ${_typeCheck.fieldTypes.join(', ')})`);
+  }
+  const field = {
+    name,
+    type,
+    optional: false,
+    autoGenerate: false
+  };
+  const seen = new Set();
+  const once = modifier => {
+    if (seen.has(modifier)) {
+      throw new Error(`"${modifier}" is given twice for field "${name}"`);
+    }
+    seen.add(modifier);
+  };
+  const tokens = rest.trim() === '' ? [] : rest.trim().split(/\s+/);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i].toLowerCase();
+    if (token === 'optional') {
+      once('optional');
+      field.optional = true;
+    } else if (token === 'auto') {
+      once('auto');
+      field.autoGenerate = true;
+    } else if (token === 'null') {
+      once('null');
+      field.nullable = true;
+    } else if (token === 'not' && (tokens[i + 1] || '').toLowerCase() === 'null') {
+      once('null');
+      field.nullable = false;
+      i++;
+    } else if (token === 'default') {
+      once('default');
+      field.useDefault = true;
+      field.defaultValue = parseDefault(tokens[++i]);
+    } else {
+      throw new Error(`Unrecognized "${shown(tokens[i])}" for field "${name}" in: ${shown(item)}`);
+    }
+  }
+  if (field.autoGenerate && field.useDefault) {
+    throw new Error(`Field "${name}" can't be both auto and have a default`);
+  }
+  if (field.autoGenerate && type !== 'string') {
+    throw new Error(`Field "${name}" is auto, which generates a UUID, so its type must be string`);
+  }
+  return field;
+};
+/**
+ * One key, or null when the item isn't written as a key (so it's a field).
+ * @param item
+ */
+const parseKey = item => {
+  let found = item.match(primaryMatch);
+  if (found) {
+    return {
+      type: 'primary',
+      fields: parseNames(found[1], item)
+    };
+  }
+  found = item.match(uniqueMatch);
+  if (found) {
+    return {
+      type: 'unique',
+      fields: parseNames(found[1], item)
+    };
+  }
+  found = item.match(indexMatch);
+  if (found) {
+    return {
+      type: 'index',
+      fields: parseNames(found[1], item)
+    };
+  }
+  found = item.match(foreignMatch);
+  if (found) {
+    const fields = parseNames(found[1], item);
+    const referenced = parseNames(found[3], item);
+    if (fields.length !== 1 || referenced.length !== 1) {
+      throw new Error(`Only single-field foreign keys are supported so far: ${shown(item)}`);
+    }
+    return {
+      type: 'foreign',
+      fields,
+      references: [{
+        fields: [`${found[2]}.${referenced[0]}`],
+        lookup: `${found[2]}.json`
+      }]
+    };
+  }
+  return null;
+};
+/**
+ * Check the keys against the fields, then name each key's index file the way create() users do by hand:
+ * `pk_`, `unique_`, `index_` or `fk_`, then the fields joined by `_` (`primary key (a, b)` is `pk_a_b.json`).
+ * @param definition
+ * @param keys
+ */
+const finishKeys = (definition, keys) => {
+  const names = definition.map(field => field.name);
+  if (keys.filter(key => key.type === 'primary').length > 1) {
+    throw new Error('Only one primary key is allowed');
+  }
+  const lookups = new Set();
+  return keys.map(key => {
+    const missing = key.fields.find(field => !names.includes(field));
+    if (missing) {
+      throw new Error(`The ${key.type} key (${key.fields.join(', ')}) names "${missing}", which is not a field`);
+    }
+    const lookup = `${lookupPrefix[key.type]}_${key.fields.join('_')}.json`;
+    if (lookups.has(lookup)) {
+      throw new Error(`The same ${key.type} key on "${key.fields.join(', ')}" is given twice`);
+    }
+    lookups.add(lookup);
+    return Object.assign({
+      type: key.type,
+      fields: key.fields,
+      lookup
+    }, key.references ? {
+      references: key.references
+    } : {});
+  });
+};
+/**
+ * Parse a create statement (strings and arrays already masked):
+ * `create [if not exists] <name> (<field>, ..., <key>, ...)`. See the README's "Creating a record". Only checks
+ * what the text alone can tell; the referenced records of foreign keys are checked when it runs.
+ * @param query
+ */
+const parseCreate = query => {
+  const head = query.match(headMatch);
+  if (!head) {
+    throw new Error('Expected: create [if not exists] <name> (<fields and keys>)');
+  }
+  const entity = head[2];
+  if (entity === '__RECORDS') {
+    throw new Error('__RECORDS is reserved for the list of records');
+  }
+  const open = head[0].length - 1;
+  const close = findClose(query, open);
+  if (close === -1) {
+    // Not reached through parser(): splitQueries' scanner already rejects an unclosed bracket
+    throw new Error('Missing ) at the end of the field list');
+  }
+  const after = query.slice(close + 1).trim();
+  if (after) {
+    if (_startsQuery.startsQueryMatch.test(after)) {
+      throw new Error(`Missing ; before: ${shown(after)}`);
+    }
+    throw new Error(`Unrecognized query value: ${shown(after)}`);
+  }
+  const body = query.slice(open + 1, close);
+  const definition = [];
+  const keys = [];
+  if (body.trim()) {
+    for (const item of splitItems(body)) {
+      if (!item) {
+        throw new Error('Empty item in the field list (an extra comma?)');
+      }
+      const key = parseKey(item);
+      if (key) {
+        keys.push(key);
+        continue;
+      }
+      const found = item.match(fieldMatch);
+      if (!found) {
+        throw new Error(`Expected a field (<name> <type> ...) or a key in: ${shown(item)}`);
+      }
+      const field = parseField(found);
+      if (definition.some(existing => existing.name === field.name)) {
+        throw new Error(`Field "${field.name}" is given twice`);
+      }
+      definition.push(field);
+    }
+  }
+  return {
+    entity,
+    create: {
+      ifNotExists: Boolean(head[1]),
+      definition,
+      keys: finishKeys(definition, keys)
+    }
+  };
+};
+exports.parseCreate = parseCreate;

package/dist/data/utilities/parsers/parseCreate.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseCreate=exports.createMatch=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.iterator.some.js"),require("core-js/modules/esnext.set.add-all.js"),require("core-js/modules/esnext.set.delete-all.js"),require("core-js/modules/esnext.set.difference.js"),require("core-js/modules/esnext.set.every.js"),require("core-js/modules/esnext.set.filter.js"),require("core-js/modules/esnext.set.find.js"),require("core-js/modules/esnext.set.intersection.js"),require("core-js/modules/esnext.set.is-disjoint-from.js"),require("core-js/modules/esnext.set.is-subset-of.js"),require("core-js/modules/esnext.set.is-superset-of.js"),require("core-js/modules/esnext.set.join.js"),require("core-js/modules/esnext.set.map.js"),require("core-js/modules/esnext.set.reduce.js"),require("core-js/modules/esnext.set.some.js"),require("core-js/modules/esnext.set.symmetric-difference.js"),require("core-js/modules/esnext.set.union.js");var _typeCheck=require("../../introspect/policies/typeCheck"),_maskStrings=require("./maskStrings"),_startsQuery=require("./startsQuery");const createMatch=exports.createMatch=/^\s*create(?![a-z0-9_-])/i,headMatch=/^\s*create\s+(if\s+not\s+exists\s+)?([a-z0-9_-]+)\s*\(/i,nameSource="[a-z0-9_-]+",nameMatch=new RegExp(`^${nameSource}$`,"i"),fieldMatch=new RegExp(`^(${nameSource})\\s+(${nameSource})((?:\\s[\\s\\S]*)?)$`,"i"),primaryMatch=/^primary\s+key\s*\(([^()]*)\)$/i,uniqueMatch=/^unique\s*\(([^()]*)\)$/i,indexMatch=/^index\s*\(([^()]*)\)$/i,foreignMatch=new RegExp(`^foreign\\s+key\\s*\\(([^()]*)\\)\\s*references\\s+(${nameSource})\\s*\\(([^()]*)\\)$`,"i"),stringLiteral=new RegExp(`^${_maskStrings.placeholderSource}$`),arrayLiteral=new RegExp(`^${_maskStrings.arraySource}$`),lookupPrefix={primary:"pk",unique:"unique",index:"index",foreign:"fk"},shown=e=>(0,_maskStrings.unmaskStrings)(e.trim(),"'"),findClose=(e,r)=>{let s=0;for(let t=r;t<e.length;t++)if("("===e[t])s++;else if(")"===e[t]&&(s--,0===s))return t;return-1},splitItems=e=>{const r=[];let s=0,t=0;for(let i=0;i<e.length;i++)"("===e[i]?s++:")"===e[i]?s--:","===e[i]&&0===s&&(r.push(e.slice(t,i)),t=i+1);return r.push(e.slice(t)),r.map((e=>e.trim()))},parseNames=(e,r)=>{const s=e.split(",").map((e=>e.trim()));if(s.some((e=>!nameMatch.test(e))))throw new Error(`Expected field names separated by commas in: ${shown(r)}`);if(new Set(s).size!==s.length)throw new Error(`The same field is named twice in: ${shown(r)}`);return s},parseDefault=e=>{if(void 0===e)throw new Error("Missing a value after default");const r=e.match(stringLiteral);if(r)return(0,_maskStrings.fromPlaceholder)(r[1]);const s=e.match(arrayLiteral);if(s)return JSON.parse((0,_maskStrings.fromPlaceholder)(s[1]));if(/^[0-9]+$/.test(e))return Number(e);switch(e.toLowerCase()){case"null":return null;case"true":return!0;case"false":return!1}throw new Error(`Unrecognized default value: ${shown(e)}`)},parseField=e=>{const[r,s,t,i]=e,n=t.toLowerCase();if(!_typeCheck.fieldTypes.includes(n))throw new Error(`Unknown type "${t}" for field "${s}" (expected ${_typeCheck.fieldTypes.join(", ")})`);const o={name:s,type:n,optional:!1,autoGenerate:!1},a=new Set,l=e=>{if(a.has(e))throw new Error(`"${e}" is given twice for field "${s}"`);a.add(e)},u=""===i.trim()?[]:i.trim().split(/\s+/);for(let e=0;e<u.length;e++){const t=u[e].toLowerCase();if("optional"===t)l("optional"),o.optional=!0;else if("auto"===t)l("auto"),o.autoGenerate=!0;else if("null"===t)l("null"),o.nullable=!0;else if("not"===t&&"null"===(u[e+1]||"").toLowerCase())l("null"),o.nullable=!1,e++;else{if("default"!==t)throw new Error(`Unrecognized "${shown(u[e])}" for field "${s}" in: ${shown(r)}`);l("default"),o.useDefault=!0,o.defaultValue=parseDefault(u[++e])}}if(o.autoGenerate&&o.useDefault)throw new Error(`Field "${s}" can't be both auto and have a default`);if(o.autoGenerate&&"string"!==n)throw new Error(`Field "${s}" is auto, which generates a UUID, so its type must be string`);return o},parseKey=e=>{let r=e.match(primaryMatch);if(r)return{type:"primary",fields:parseNames(r[1],e)};if(r=e.match(uniqueMatch),r)return{type:"unique",fields:parseNames(r[1],e)};if(r=e.match(indexMatch),r)return{type:"index",fields:parseNames(r[1],e)};if(r=e.match(foreignMatch),r){const s=parseNames(r[1],e),t=parseNames(r[3],e);if(1!==s.length||1!==t.length)throw new Error(`Only single-field foreign keys are supported so far: ${shown(e)}`);return{type:"foreign",fields:s,references:[{fields:[`${r[2]}.${t[0]}`],lookup:`${r[2]}.json`}]}}return null},finishKeys=(e,r)=>{const s=e.map((e=>e.name));if(r.filter((e=>"primary"===e.type)).length>1)throw new Error("Only one primary key is allowed");const t=new Set;return r.map((e=>{const r=e.fields.find((e=>!s.includes(e)));if(r)throw new Error(`The ${e.type} key (${e.fields.join(", ")}) names "${r}", which is not a field`);const i=`${lookupPrefix[e.type]}_${e.fields.join("_")}.json`;if(t.has(i))throw new Error(`The same ${e.type} key on "${e.fields.join(", ")}" is given twice`);return t.add(i),Object.assign({type:e.type,fields:e.fields,lookup:i},e.references?{references:e.references}:{})}))},parseCreate=e=>{const r=e.match(headMatch);if(!r)throw new Error("Expected: create [if not exists] <name> (<fields and keys>)");const s=r[2];if("__RECORDS"===s)throw new Error("__RECORDS is reserved for the list of records");const t=r[0].length-1,i=findClose(e,t);if(-1===i)throw new Error("Missing ) at the end of the field list");const n=e.slice(i+1).trim();if(n){if(_startsQuery.startsQueryMatch.test(n))throw new Error(`Missing ; before: ${shown(n)}`);throw new Error(`Unrecognized query value: ${shown(n)}`)}const o=e.slice(t+1,i),a=[],l=[];if(o.trim())for(const e of splitItems(o)){if(!e)throw new Error("Empty item in the field list (an extra comma?)");const r=parseKey(e);if(r){l.push(r);continue}const s=e.match(fieldMatch);if(!s)throw new Error(`Expected a field (<name> <type> ...) or a key in: ${shown(e)}`);const t=parseField(s);if(a.some((e=>e.name===t.name)))throw new Error(`Field "${t.name}" is given twice`);a.push(t)}return{entity:s,create:{ifNotExists:Boolean(r[1]),definition:a,keys:finishKeys(a,l)}}};exports.parseCreate=parseCreate;

package/dist/data/utilities/parsers/parseLiteralValue.d.ts

@@ -1,7 +1,8 @@
 export type LiteralValue = string | number | boolean | null | any[];
 /**
  * Several parsers (findConditions, findInsertValues, findUpdateValues) capture a query-string
- * literal into one of six consecutive alternation groups depending on its shape - quoted string,
+ * literal into one of six consecutive alternation groups depending on its shape - quoted string
+ * (by then a placeholder from maskStrings, holding the string's value as hex),
  * number, array, null, true, false - since a single regex can't otherwise tell them apart. Given
  * the match and the index of the first of those six groups (which shifts depending on how many
  * groups come before it in the parent regex), return the literal with its real JS type.

package/dist/data/utilities/parsers/parseLiteralValue.js

@@ -4,9 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parseLiteralValue = void 0;
+var _maskStrings = require("./maskStrings");
 /**
  * Several parsers (findConditions, findInsertValues, findUpdateValues) capture a query-string
- * literal into one of six consecutive alternation groups depending on its shape - quoted string,
+ * literal into one of six consecutive alternation groups depending on its shape - quoted string
+ * (by then a placeholder from maskStrings, holding the string's value as hex),
  * number, array, null, true, false - since a single regex can't otherwise tell them apart. Given
  * the match and the index of the first of those six groups (which shifts depending on how many
  * groups come before it in the parent regex), return the literal with its real JS type.
@@ -15,13 +17,14 @@ exports.parseLiteralValue = void 0;
  */
 const parseLiteralValue = (match, baseIndex) => {
   if (typeof match[baseIndex] !== 'undefined') {
-    return match[baseIndex];
+    return (0, _maskStrings.fromPlaceholder)(match[baseIndex]);
   }
   if (typeof match[baseIndex + 1] !== 'undefined') {
     return Number(match[baseIndex + 1]);
   }
   if (typeof match[baseIndex + 2] !== 'undefined') {
-    return JSON.parse(match[baseIndex + 2]);
+    // An array is a placeholder from maskArrays, holding its JSON
+    return JSON.parse((0, _maskStrings.fromPlaceholder)(match[baseIndex + 2]));
   }
   if (typeof match[baseIndex + 3] !== 'undefined') {
     return null;

package/dist/data/utilities/parsers/parseLiteralValue.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseLiteralValue=void 0;const parseLiteralValue=(e,r)=>void 0!==e[r]?e[r]:void 0!==e[r+1]?Number(e[r+1]):void 0!==e[r+2]?JSON.parse(e[r+2]):void 0!==e[r+3]?null:void 0!==e[r+4];exports.parseLiteralValue=parseLiteralValue;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseLiteralValue=void 0;var _maskStrings=require("./maskStrings");const parseLiteralValue=(e,r)=>void 0!==e[r]?(0,_maskStrings.fromPlaceholder)(e[r]):void 0!==e[r+1]?Number(e[r+1]):void 0!==e[r+2]?JSON.parse((0,_maskStrings.fromPlaceholder)(e[r+2])):void 0!==e[r+3]?null:void 0!==e[r+4];exports.parseLiteralValue=parseLiteralValue;

package/dist/data/utilities/parsers/parseQuery.d.ts

@@ -10,6 +10,7 @@ import { ParsedSortClause } from './findSortClauses';
 import { ParsedGroupBy } from './findGroupBy';
 import { ParsedLimit } from './findLimit';
 import { ParsedOffset } from './findOffset';
+import { ParsedCreate } from './parseCreate';
 export type ParsedQuery = {
     command: ParsedCommand | undefined;
     entity: ParsedEntity | undefined;
@@ -24,6 +25,8 @@ export type ParsedQuery = {
     groupBy: ParsedGroupBy | undefined;
     limit: ParsedLimit | undefined;
     offset: ParsedOffset | undefined;
+    create: ParsedCreate | undefined;
+    ifExists: boolean | undefined;
 };
 /**
  * Break a query down into its components.

package/dist/data/utilities/parsers/parseQuery.js

@@ -17,6 +17,10 @@ var _findSortClauses = require("./findSortClauses");
 var _findGroupBy = require("./findGroupBy");
 var _findLimit = require("./findLimit");
 var _findOffset = require("./findOffset");
+var _maskStrings = require("./maskStrings");
+var _parseCreate = require("./parseCreate");
+var _parseSchemaStatement = require("./parseSchemaStatement");
+var _startsQuery = require("./startsQuery");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * Break a query down into its components.
@@ -36,15 +40,37 @@ const parseQuery = query => {
     sortClauses: [],
     groupBy: undefined,
     limit: undefined,
-    offset: undefined
+    offset: undefined,
+    create: undefined,
+    ifExists: undefined
   };
   const {
     curry,
     pipe
   } = _siFunciona.default;
+  // No find* step may see inside a string or an array: each one becomes a placeholder holding its value
+  query = (0, _maskStrings.maskArrays)((0, _maskStrings.maskStrings)(query));
+  // A create statement has its own shape (a bracketed list of fields and keys), so it gets its own parser
+  if (_parseCreate.createMatch.test(query)) {
+    const {
+      entity,
+      create
+    } = (0, _parseCreate.parseCreate)(query);
+    return Object.assign(parsedQuery, {
+      command: 'create',
+      entity,
+      create
+    });
+  }
+  if (_parseSchemaStatement.schemaStatementMatch.test(query)) {
+    return Object.assign(parsedQuery, (0, _parseSchemaStatement.parseSchemaStatement)(query));
+  }
   query = pipe(curry(_findCommand.findCommand)(parsedQuery), curry(_findInsertValues.findInsertValues)(parsedQuery), curry(_findUpdateValues.findUpdateValues)(parsedQuery), curry(_findJoinEntity.findJoinEntity)(parsedQuery), curry(_findSelects.findSelects)(parsedQuery), curry(_findConditions.findConditions)(parsedQuery), curry(_findJoinClauses.findJoinClauses)(parsedQuery), curry(_findMergeJoins.findMergeJoins)(parsedQuery), curry(_findSortClauses.findSortClauses)(parsedQuery), curry(_findGroupBy.findGroupBy)(parsedQuery), curry(_findLimit.findLimit)(parsedQuery), curry(_findOffset.findOffset)(parsedQuery))(query);
   if (query) {
-    throw new Error(`Unrecognized query value: ${query}`);
+    if (_startsQuery.startsQueryMatch.test(query)) {
+      throw new Error(`Missing ; before: ${(0, _maskStrings.unmaskStrings)(query.trim(), '\'')}`);
+    }
+    throw new Error(`Unrecognized query value: ${(0, _maskStrings.unmaskStrings)(query, '\'')}`);
   }
   return parsedQuery;
 };

package/dist/data/utilities/parsers/parseQuery.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseQuery=void 0;var _siFunciona=_interopRequireDefault(require("si-funciona")),_findCommand=require("./findCommand"),_findInsertValues=require("./findInsertValues"),_findUpdateValues=require("./findUpdateValues"),_findJoinEntity=require("./findJoinEntity"),_findSelects=require("./findSelects"),_findConditions=require("./findConditions"),_findJoinClauses=require("./findJoinClauses"),_findMergeJoins=require("./findMergeJoins"),_findSortClauses=require("./findSortClauses"),_findGroupBy=require("./findGroupBy"),_findLimit=require("./findLimit"),_findOffset=require("./findOffset");function _interopRequireDefault(i){return i&&i.__esModule?i:{default:i}}const parseQuery=i=>{const e={command:void 0,entity:void 0,joinEntity:void 0,selectClauses:[],insertValues:[],updateValues:{},conditions:[],joinClauses:[],mergeJoins:[],sortClauses:[],groupBy:void 0,limit:void 0,offset:void 0},{curry:n,pipe:r}=_siFunciona.default;if(i=r(n(_findCommand.findCommand)(e),n(_findInsertValues.findInsertValues)(e),n(_findUpdateValues.findUpdateValues)(e),n(_findJoinEntity.findJoinEntity)(e),n(_findSelects.findSelects)(e),n(_findConditions.findConditions)(e),n(_findJoinClauses.findJoinClauses)(e),n(_findMergeJoins.findMergeJoins)(e),n(_findSortClauses.findSortClauses)(e),n(_findGroupBy.findGroupBy)(e),n(_findLimit.findLimit)(e),n(_findOffset.findOffset)(e))(i))throw new Error(`Unrecognized query value: ${i}`);return e};exports.parseQuery=parseQuery;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseQuery=void 0;var _siFunciona=_interopRequireDefault(require("si-funciona")),_findCommand=require("./findCommand"),_findInsertValues=require("./findInsertValues"),_findUpdateValues=require("./findUpdateValues"),_findJoinEntity=require("./findJoinEntity"),_findSelects=require("./findSelects"),_findConditions=require("./findConditions"),_findJoinClauses=require("./findJoinClauses"),_findMergeJoins=require("./findMergeJoins"),_findSortClauses=require("./findSortClauses"),_findGroupBy=require("./findGroupBy"),_findLimit=require("./findLimit"),_findOffset=require("./findOffset"),_maskStrings=require("./maskStrings"),_parseCreate=require("./parseCreate"),_parseSchemaStatement=require("./parseSchemaStatement"),_startsQuery=require("./startsQuery");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const parseQuery=e=>{const i={command:void 0,entity:void 0,joinEntity:void 0,selectClauses:[],insertValues:[],updateValues:{},conditions:[],joinClauses:[],mergeJoins:[],sortClauses:[],groupBy:void 0,limit:void 0,offset:void 0,create:void 0,ifExists:void 0},{curry:n,pipe:r}=_siFunciona.default;if(e=(0,_maskStrings.maskArrays)((0,_maskStrings.maskStrings)(e)),_parseCreate.createMatch.test(e)){const{entity:n,create:r}=(0,_parseCreate.parseCreate)(e);return Object.assign(i,{command:"create",entity:n,create:r})}if(_parseSchemaStatement.schemaStatementMatch.test(e))return Object.assign(i,(0,_parseSchemaStatement.parseSchemaStatement)(e));if(e=r(n(_findCommand.findCommand)(i),n(_findInsertValues.findInsertValues)(i),n(_findUpdateValues.findUpdateValues)(i),n(_findJoinEntity.findJoinEntity)(i),n(_findSelects.findSelects)(i),n(_findConditions.findConditions)(i),n(_findJoinClauses.findJoinClauses)(i),n(_findMergeJoins.findMergeJoins)(i),n(_findSortClauses.findSortClauses)(i),n(_findGroupBy.findGroupBy)(i),n(_findLimit.findLimit)(i),n(_findOffset.findOffset)(i))(e)){if(_startsQuery.startsQueryMatch.test(e))throw new Error(`Missing ; before: ${(0,_maskStrings.unmaskStrings)(e.trim(),"'")}`);throw new Error(`Unrecognized query value: ${(0,_maskStrings.unmaskStrings)(e,"'")}`)}return i};exports.parseQuery=parseQuery;

package/dist/data/utilities/parsers/parseSchemaStatement.d.ts

@@ -0,0 +1,13 @@
+export type ParsedSchemaStatement = {
+    command: 'drop' | 'describe' | 'show';
+    entity: string;
+    ifExists: boolean;
+};
+export declare const schemaStatementMatch: RegExp;
+/**
+ * Parse `drop [if exists] <name>`, `describe <name>` or `show records` (strings and arrays already masked). `show`
+ * resolves to the registry, so its entity is `__RECORDS`.
+ * @param query
+ */
+export declare const parseSchemaStatement: (query: string) => ParsedSchemaStatement;
+//# sourceMappingURL=parseSchemaStatement.d.ts.map

package/dist/data/utilities/parsers/parseSchemaStatement.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.schemaStatementMatch = exports.parseSchemaStatement = void 0;
+var _maskStrings = require("./maskStrings");
+var _startsQuery = require("./startsQuery");
+const schemaStatementMatch = exports.schemaStatementMatch = /^\s*(drop|describe|show)(?![a-z0-9_-])/i;
+const dropMatch = /^\s*drop\s+(if\s+exists\s+)?([a-z0-9_-]+)/i;
+const describeMatch = /^\s*describe\s+([a-z0-9_-]+)/i;
+const showMatch = /^\s*show\s+records(?![a-z0-9_-])/i;
+/**
+ * Throw for anything left after a statement: "Missing ; before" when it is another query.
+ * @param rest
+ */
+const assertNothingAfter = rest => {
+  const after = rest.trim();
+  if (!after) {
+    return;
+  }
+  const shown = (0, _maskStrings.unmaskStrings)(after, '\'');
+  if (_startsQuery.startsQueryMatch.test(after)) {
+    throw new Error(`Missing ; before: ${shown}`);
+  }
+  throw new Error(`Unrecognized query value: ${shown}`);
+};
+/**
+ * Throw for the registry's own name, which the schema statements don't act on.
+ * @param entity
+ */
+const assertNotRegistry = entity => {
+  if (entity === '__RECORDS') {
+    throw new Error('__RECORDS is reserved for the list of records (use: show records)');
+  }
+};
+/**
+ * Parse `drop [if exists] <name>`, `describe <name>` or `show records` (strings and arrays already masked). `show`
+ * resolves to the registry, so its entity is `__RECORDS`.
+ * @param query
+ */
+const parseSchemaStatement = query => {
+  const command = query.match(schemaStatementMatch)[1].toLowerCase();
+  if (command === 'drop') {
+    const found = query.match(dropMatch);
+    // `drop if exists` with no name would otherwise read `if` as the name
+    if (!found || /^\s*drop\s+if\s+exists\s*$/i.test(query)) {
+      throw new Error('Expected: drop [if exists] <name>');
+    }
+    assertNotRegistry(found[2]);
+    assertNothingAfter(query.slice(found[0].length));
+    return {
+      command: 'drop',
+      entity: found[2],
+      ifExists: Boolean(found[1])
+    };
+  }
+  if (command === 'describe') {
+    const found = query.match(describeMatch);
+    if (!found) {
+      throw new Error('Expected: describe <name>');
+    }
+    assertNotRegistry(found[1]);
+    assertNothingAfter(query.slice(found[0].length));
+    return {
+      command: 'describe',
+      entity: found[1],
+      ifExists: false
+    };
+  }
+  const found = query.match(showMatch);
+  if (!found) {
+    throw new Error('Expected: show records (the only thing that can be shown so far)');
+  }
+  assertNothingAfter(query.slice(found[0].length));
+  return {
+    command: 'show',
+    entity: '__RECORDS',
+    ifExists: false
+  };
+};
+exports.parseSchemaStatement = parseSchemaStatement;

package/dist/data/utilities/parsers/parseSchemaStatement.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.schemaStatementMatch=exports.parseSchemaStatement=void 0;var _maskStrings=require("./maskStrings"),_startsQuery=require("./startsQuery");const schemaStatementMatch=exports.schemaStatementMatch=/^\s*(drop|describe|show)(?![a-z0-9_-])/i,dropMatch=/^\s*drop\s+(if\s+exists\s+)?([a-z0-9_-]+)/i,describeMatch=/^\s*describe\s+([a-z0-9_-]+)/i,showMatch=/^\s*show\s+records(?![a-z0-9_-])/i,assertNothingAfter=e=>{const t=e.trim();if(!t)return;const s=(0,_maskStrings.unmaskStrings)(t,"'");if(_startsQuery.startsQueryMatch.test(t))throw new Error(`Missing ; before: ${s}`);throw new Error(`Unrecognized query value: ${s}`)},assertNotRegistry=e=>{if("__RECORDS"===e)throw new Error("__RECORDS is reserved for the list of records (use: show records)")},parseSchemaStatement=e=>{const t=e.match(schemaStatementMatch)[1].toLowerCase();if("drop"===t){const t=e.match(dropMatch);if(!t||/^\s*drop\s+if\s+exists\s*$/i.test(e))throw new Error("Expected: drop [if exists] <name>");return assertNotRegistry(t[2]),assertNothingAfter(e.slice(t[0].length)),{command:"drop",entity:t[2],ifExists:Boolean(t[1])}}if("describe"===t){const t=e.match(describeMatch);if(!t)throw new Error("Expected: describe <name>");return assertNotRegistry(t[1]),assertNothingAfter(e.slice(t[0].length)),{command:"describe",entity:t[1],ifExists:!1}}const s=e.match(showMatch);if(!s)throw new Error("Expected: show records (the only thing that can be shown so far)");return assertNothingAfter(e.slice(s[0].length)),{command:"show",entity:"__RECORDS",ifExists:!1}};exports.parseSchemaStatement=parseSchemaStatement;

package/dist/data/utilities/parsers/scanQuery.d.ts

@@ -0,0 +1,52 @@
+export type QuoteChar = '\'' | '"';
+export type BracketChar = '[' | '(';
+export type ScannedString = {
+    start: number;
+    end: number;
+    quote: QuoteChar;
+    value: string;
+};
+export type ScannedComment = {
+    start: number;
+    end: number;
+    kind: 'line' | 'block';
+};
+export type ScanState = {
+    quote: QuoteChar | undefined;
+    escape: boolean;
+    blockComment: boolean;
+    brackets: BracketChar[];
+    strayCloser: {
+        char: string;
+        index: number;
+    } | undefined;
+};
+export type ScannedQuery = {
+    strings: ScannedString[];
+    comments: ScannedComment[];
+    semicolons: number[];
+    end: ScanState;
+    closed: boolean;
+    terminated: boolean;
+};
+/**
+ * Walk a query once, left to right, finding its strings, comments and the `;` between statements.
+ *
+ * Strings use `'` or `"` and close only with the quote they opened with. Inside a string a backslash escapes the
+ * next character: `\n` and `\t` are a newline and a tab, any other `\x` is `x` (so `\'`, `\"` and `\\` are a quote
+ * and a backslash). Outside strings a backslash has no meaning. Comments run from `--` to the end of the line, or
+ * from `/*` to `*\/`; anything inside a comment is ignored, and comment markers inside a string are just text. A `--`
+ * starts a comment only at the start of the text or after whitespace or a `;`, since names can contain `-`
+ * (`my--table` is a name). A `;` inside brackets does not end a query.
+ *
+ * Never throws: whatever is left open is reported in `end`, for a prompt which asks for more input. Use
+ * assertClosed to turn it into an error.
+ * @param text
+ */
+export declare const scanQuery: (text?: string) => ScannedQuery;
+/**
+ * Throw a clear error for anything scanQuery found left open or unmatched: a string, a block comment or a bracket.
+ * @param scanned
+ */
+export declare const assertClosed: (scanned: ScannedQuery) => ScannedQuery;
+//# sourceMappingURL=scanQuery.d.ts.map