json-fs-query 1.0.6 → 2.0.0

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

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unmaskStrings = exports.placeholderSource = exports.maskStrings = exports.maskArrays = exports.fromPlaceholder = exports.arraySource = void 0;
+require("core-js/modules/es.json.stringify.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.iterator.some.js");
+var _scanQuery = require("./scanQuery");
+/**
+ * Regex source matching one placeholder from maskStrings, with the hex-encoded value as its only group. The
+ * find* parsers use it where they would otherwise match a quoted string.
+ */
+const placeholderSource = exports.placeholderSource = '\\u0000([0-9a-f]*)\\u0000';
+const placeholderMatch = new RegExp(placeholderSource, 'g');
+/**
+ * Regex source matching one placeholder from maskArrays, with the hex-encoded JSON of the array as its only group.
+ * The find* parsers use it where they would otherwise match `[...]`.
+ */
+const arraySource = exports.arraySource = '\\u0001([0-9a-f]*)\\u0001';
+const arrayMatch = new RegExp(arraySource, 'g');
+/**
+ * Encode a value as hex, four digits per UTF-16 code unit: only 0-9 and a-f, so no keyword, quote, space or
+ * bracket a parser looks for can appear in it.
+ * @param value
+ */
+const toHex = value => value.split('').map(char => char.charCodeAt(0).toString(16).padStart(4, '0')).join('');
+/**
+ * Turn the hex of a placeholder back into the string's value.
+ * @param hex
+ */
+const fromPlaceholder = hex => (hex.match(/.{4}/g) || []).map(code => String.fromCharCode(parseInt(code, 16))).join('');
+/**
+ * Replace every quoted string in a query with a placeholder holding its value (with the escapes applied), so that
+ * nothing inside a string (a keyword, a quote, `and`, a `]`) can be matched by the find* parsers.
+ * @param query
+ * @throws {Error} For an unclosed string, comment or bracket, or a NUL or SOH character outside a string (which
+ * could otherwise pass for a placeholder).
+ */
+exports.fromPlaceholder = fromPlaceholder;
+const maskStrings = query => {
+  const {
+    strings
+  } = (0, _scanQuery.assertClosed)((0, _scanQuery.scanQuery)(query));
+  for (const [character, name] of [['\u0000', 'NUL'], ['\u0001', 'SOH']]) {
+    for (let index = query.indexOf(character); index !== -1; index = query.indexOf(character, index + 1)) {
+      if (!strings.some(({
+        start,
+        end
+      }) => start < index && index < end)) {
+        throw new Error(`Unexpected ${name} character at position ${index}`);
+      }
+    }
+  }
+  return strings.reduceRight((masked, {
+    start,
+    end,
+    value
+  }) => `${masked.slice(0, start)}\u0000${toHex(value)}\u0000${masked.slice(end)}`, query);
+};
+/**
+ * Put every placeholder back the way it would be written in a query: strings quoted, arrays as JSON. For error
+ * messages, and for reading an array's text as JSON.
+ * @param text
+ * @param quote - wrap strings with JSON's double quotes (the default) or with single quotes
+ */
+exports.maskStrings = maskStrings;
+const unmaskStrings = (text, quote = 'json') => text.replace(placeholderMatch, (placeholder, hex) => {
+  const value = fromPlaceholder(hex);
+  return quote === 'json' ? JSON.stringify(value) : `'${value.replace(/\\/g, '\\\\').replace(/'/g, '\\\'')}'`;
+}).replace(arrayMatch, (placeholder, hex) => fromPlaceholder(hex));
+/**
+ * Read one array's text (its strings already placeholders) as JSON, so it is checked once, here, with a clear error.
+ * @param text
+ */
+exports.unmaskStrings = unmaskStrings;
+const arrayJson = text => {
+  try {
+    // A number too big for a double reads as Infinity, which JSON would write back as null: refuse it instead
+    return JSON.stringify(JSON.parse(unmaskStrings(text), (key, value) => {
+      if (typeof value === 'number' && !Number.isFinite(value)) {
+        throw new Error(`${value} is too large`);
+      }
+      return value;
+    }));
+  } catch (e) {
+    throw new Error(`Invalid array ${unmaskStrings(text, '\'')}: ${e.message}`);
+  }
+};
+/**
+ * Replace every array (outermost brackets only, so a nested array stays inside its parent) with a placeholder holding
+ * its JSON, so that the find* parsers never have to find where an array ends, and nothing inside one (a `.`, a `]`,
+ * a keyword) can be matched by them. Run it on the output of maskStrings, where no `[` or `]` is inside a string.
+ * @param masked
+ * @throws {Error} For an array which is not valid JSON once its strings are put back.
+ */
+const maskArrays = masked => {
+  let result = '';
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < masked.length; index++) {
+    const char = masked[index];
+    if (char === '[') {
+      if (depth === 0) {
+        start = index;
+      }
+      depth++;
+    } else if (char === ']' && depth > 0) {
+      depth--;
+      if (depth === 0) {
+        result += `\u0001${toHex(arrayJson(masked.slice(start, index + 1)))}\u0001`;
+        continue;
+      }
+    }
+    if (depth === 0) {
+      result += char;
+    }
+  }
+  return depth > 0 ? result + masked.slice(start) : result;
+};
+exports.maskArrays = maskArrays;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.unmaskStrings=exports.placeholderSource=exports.maskStrings=exports.maskArrays=exports.fromPlaceholder=exports.arraySource=void 0,require("core-js/modules/es.json.stringify.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.iterator.some.js");var _scanQuery=require("./scanQuery");const placeholderSource=exports.placeholderSource="\\u0000([0-9a-f]*)\\u0000",placeholderMatch=new RegExp(placeholderSource,"g"),arraySource=exports.arraySource="\\u0001([0-9a-f]*)\\u0001",arrayMatch=new RegExp(arraySource,"g"),toHex=r=>r.split("").map((r=>r.charCodeAt(0).toString(16).padStart(4,"0"))).join(""),fromPlaceholder=r=>(r.match(/.{4}/g)||[]).map((r=>String.fromCharCode(parseInt(r,16)))).join("");exports.fromPlaceholder=fromPlaceholder;const maskStrings=r=>{const{strings:e}=(0,_scanQuery.assertClosed)((0,_scanQuery.scanQuery)(r));for(const[s,o]of[["\0","NUL"],["
","SOH"]])for(let t=r.indexOf(s);-1!==t;t=r.indexOf(s,t+1))if(!e.some((({start:r,end:e})=>r<t&&t<e)))throw new Error(`Unexpected ${o} character at position ${t}`);return e.reduceRight(((r,{start:e,end:s,value:o})=>`${r.slice(0,e)}\0${toHex(o)}\0${r.slice(s)}`),r)};exports.maskStrings=maskStrings;const unmaskStrings=(r,e="json")=>r.replace(placeholderMatch,((r,s)=>{const o=fromPlaceholder(s);return"json"===e?JSON.stringify(o):`'${o.replace(/\\/g,"\\\\").replace(/'/g,"\\'")}'`})).replace(arrayMatch,((r,e)=>fromPlaceholder(e)));exports.unmaskStrings=unmaskStrings;const arrayJson=r=>{try{return JSON.stringify(JSON.parse(unmaskStrings(r),((r,e)=>{if("number"==typeof e&&!Number.isFinite(e))throw new Error(`${e} is too large`);return e})))}catch(e){throw new Error(`Invalid array ${unmaskStrings(r,"'")}: ${e.message}`)}},maskArrays=r=>{let e="",s=0,o=0;for(let t=0;t<r.length;t++){const a=r[t];if("["===a)0===s&&(o=t),s++;else if("]"===a&&s>0&&(s--,0===s)){e+=`
${toHex(arrayJson(r.slice(o,t+1)))}
`;continue}0===s&&(e+=a)}return s>0?e+r.slice(o):e};exports.maskArrays=maskArrays;

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

@@ -0,0 +1,20 @@
+import { fieldProperties } from '../../introspect/definitions/field';
+import { keyProperties } from '../../introspect/definitions/key';
+export type ParsedCreate = {
+    ifNotExists: boolean;
+    definition: fieldProperties[];
+    keys: keyProperties[];
+};
+export type ParsedCreateQuery = {
+    entity: string;
+    create: ParsedCreate;
+};
+export declare const createMatch: RegExp;
+/**
+ * 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
+ */
+export declare const parseCreate: (query: string) => ParsedCreateQuery;
+//# sourceMappingURL=parseCreate.d.ts.map

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