tamedevil 0.0.0-0.1

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# tamedevil
+
+## 0.0.0-0.1
+
+### Patch Changes
+
+- [`cd37fd02a`](undefined) - Introduce new tamedevil package for managing JIT
+  code

package/LICENSE.md

@@ -0,0 +1,20 @@
+# The MIT License (MIT)
+
+Copyright © `2023` Benjie Gillam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,315 @@
+# tamedevil
+
+[![GitHub Sponsors](https://img.shields.io/github/sponsors/benjie?color=ff69b4&label=github%20sponsors)](https://github.com/sponsors/benjie)
+[![Patreon sponsor button](https://img.shields.io/badge/sponsor-via%20Patreon-orange.svg)](https://patreon.com/benjie)
+[![Discord chat room](https://img.shields.io/discord/489127045289476126.svg)](http://discord.gg/graphile)
+[![Follow](https://img.shields.io/badge/twitter-@GraphileHQ-blue.svg)](https://twitter.com/GraphileHQ)
+
+**Eval is evil, this module helps tame it!**
+
+It's generally recommended that you don't use `eval` or `new Function` when
+writing JavaScript/TypeScript code. There's many many reasons for this, here are
+but a few:
+
+- **code injection**: without sufficient caution, attackers could inject
+  poisoned strings into your `eval`s and you might unwittingly start evaluating
+  their code, which can lead to extremely serious security incidents
+- **garbage collection**: `eval` (and, to a lesser extend, `new Function`) are
+  hard for the JS engine to understand, which can result in values that should
+  have been garbage collected instead being retained just in case
+- **debugging**: errors thrown from or issues inside of evaluated code are hard
+  to inspect, they don't have line numbers that match up with your source code
+
+However, `eval` and `new Function` can be powerful tools for building performant
+code - if you have a list of operations to perform, it may be much more
+performant to build a dynamic function to evaluate those operations at native JS
+speed rather than to build your own interpretter.
+
+`tamedevil` makes it much safer to build this kind of dynamic function, by
+ensuring that every string and substring that is to be evaluated is either code
+that you, the author, has written (it's something "you know"), or is some text
+that has been suitably escaped - this helps to address the **code injection**
+concern. We accomplish this with the power of tagged template literals and
+symbols.
+
+We also attempt to address the **garbage collection** concern by ensuring that
+there is no ephemeral data in the closure in which the code is evaluated, so
+nothing to be garbage collected. Note that we **do not** capture the closure in
+which you define the string - all parameters must be passed explicitly (via the
+helpers), which is one reason we use `new Function` rather than `eval` under the
+hood.
+
+<!-- SPONSORS_BEGIN -->
+
+## Crowd-funded open-source software
+
+To help us develop this software sustainably under the MIT license, we ask all
+individuals and businesses that use it to help support its ongoing maintenance
+and development via sponsorship.
+
+### [Click here to find out more about sponsors and sponsorship.](https://www.graphile.org/sponsor/)
+
+And please give some love to our featured sponsors 🤩:
+
+<table><tr>
+<td align="center"><a href="https://surge.io/"><img src="https://graphile.org/images/sponsors/surge.png" width="90" height="90" alt="Surge" /><br />Surge</a> *</td>
+<td align="center"><a href="https://www.netflix.com/"><img src="https://graphile.org/images/sponsors/Netflix.png" width="90" height="90" alt="Netflix" /><br />Netflix</a> *</td>
+<td align="center"><a href="https://qwick.com/"><img src="https://graphile.org/images/sponsors/qwick.png" width="90" height="90" alt="Qwick" /><br />Qwick</a> *</td>
+<td align="center"><a href="https://www.the-guild.dev/"><img src="https://graphile.org/images/sponsors/theguild.png" width="90" height="90" alt="The Guild" /><br />The Guild</a> *</td>
+</tr><tr>
+<td align="center"><a href="http://chads.website"><img src="https://graphile.org/images/sponsors/chadf.png" width="90" height="90" alt="Chad Furman" /><br />Chad Furman</a> *</td>
+<td align="center"><a href="https://www.fanatics.com/"><img src="https://graphile.org/images/sponsors/fanatics.png" width="90" height="90" alt="Fanatics" /><br />Fanatics</a> *</td>
+<td align="center"><a href="https://dovetailapp.com/"><img src="https://graphile.org/images/sponsors/dovetail.png" width="90" height="90" alt="Dovetail" /><br />Dovetail</a> *</td>
+<td align="center"><a href="https://www.enzuzo.com/"><img src="https://graphile.org/images/sponsors/enzuzo.png" width="90" height="90" alt="Enzuzo" /><br />Enzuzo</a> *</td>
+</tr><tr>
+<td align="center"><a href="https://stellate.co/"><img src="https://graphile.org/images/sponsors/Stellate.png" width="90" height="90" alt="Stellate" /><br />Stellate</a> *</td>
+</tr></table>
+
+<em>\* Sponsors the entire Graphile suite</em>
+
+<!-- SPONSORS_END -->
+
+## Installation
+
+```
+yarn add tamedevil
+```
+
+or
+
+```
+npm install --save tamedevil
+```
+
+## Importing
+
+We use the abbreviation `te` to refer to the tagged template literal function,
+and all the helpers are available as properties on this function, so it's
+typically the only thing you need to import.
+
+For ESM, import `te`:
+
+<!-- skip-example -->
+
+```js
+import { te } from "tamedevil";
+```
+
+Or for CommonJS, `require` it:
+
+<!-- skip-example -->
+
+```js
+const { te } = require("tamedevil");
+```
+
+## Example
+
+```js
+// Here's a string we want to embed into the function:
+const spec = "some string here";
+
+// And here's a complex variable we want to use within the function's scope:
+const source = new Source(/* ... */);
+
+const toEval = te`\
+  const source = ${te.ref(source)};
+  return function plan($record) {
+    const $records = source.find(${te.lit(spec)});
+    return connection($records);
+  }
+`;
+
+const plan = te.run(toEval);
+
+console.log(plan.toString());
+/* Outputs:
+
+function plan($record) {
+  const $records = source.find("some string here");
+  return connection($records);
+}
+
+*/
+```
+
+## API
+
+### `` te`...` ``
+
+Builds part of (or the whole of) a JS expression, safely interpreting the
+embedded expressions. If a non `te` expression is passed in, e.g.:
+
+<!-- skip-example -->
+
+```js
+te`return 2 + ${1}`;
+```
+
+then an error will be thrown. This prevents code injection, as all values must
+go through an allowed API.
+
+### `te.ref(val)` (alias: te.reference)
+
+Tells `te` to pass the given value by reference into the scope of the function
+via a closure, and returns an identifier that can be used to reference it. Note:
+the identifier used will be randomized to avoid the risk of conflicts, so if you
+are building code that will ultimately return a function, we recommend giving
+the ref an alias outside of the function to make the function text easier to
+debug, e.g.:
+
+```js
+const source = new Source(/* ... */);
+const spec = "some string here";
+
+const toEval = te`\
+  const source = ${te.ref(source)};
+  return function plan($record) {
+    const $records = source.find(${te.lit(spec)});
+    return connection($records);
+  }
+`;
+```
+
+### `te.lit(val)` (alias: te.literal)
+
+As `te.ref`, but in the case of simple primitive values (strings, numbers,
+booleans, null, undefined) may write them directly to the code rather than
+passing them by reference, which may make the resulting code easier to read.
+
+Besides being useful for general purposes, this is the preferred way of safely
+settings keys on a dynamic object, for example:
+
+```js
+// This is a perfectly reasonable key
+const key1 = "one";
+
+// Note this key would be unsafe to set on an object created via `{}`, but is
+// fine for `Object.create(null)`
+const key2 = "__proto__";
+
+const fragment = te`\
+  const obj = Object.create(null);
+  obj[${te.lit(key1)}] = 1;
+  obj[${te.lit(key2)}] = {str: true};
+  return obj;
+`;
+```
+
+### `te.substring(str, stringType)`
+
+If you're building a string and you want to inject untrusted content into it
+without opening yourself to code injection attacks, this is the method for you.
+Pass the string you'd like escaped as the first argument, and the second
+argument should be `"`, `'` or `` ` `` depending on what type of string you're
+embedding into. Example:
+
+```js
+const code = te`const str = "abc${te.substring(untrusted, '"')}123";`;
+```
+
+### `te.join(arrayOfFragments, delimiter)`
+
+Joins an array of `te` values using the delimiter (a plain string); e.g.
+
+```js
+const keysAndValues = ["a", "b", "c", "d"].map(
+  (n, i) => te`${te.dangerousKey(n)}: ${te.literal(i)}`,
+);
+const obj = te`{ ${te.join(keysAndValues, ", ")} }`;
+// obj = { a: 0, b: 1, c: 2, d: 3 }
+```
+
+### `te.identifier(name)`
+
+Takes `name` (string) and returns a `TE` node for it if it could be a reasonable
+name for a variable. If it doesn't seem a reasonable name then it will instead
+throw an error, so be warned! This means that it will throw an error if any JS
+reserved words are used, or if the name is potentially confusing (e.g. `async`).
+For a full list of the _current_ reserved words, see
+[reservedWords.ts](./src/reservedWords.ts), but not that these words may change
+in a minor release.
+
+This is not intended to be used with untrusted user data, it's just a
+convenience method to use for example if you want to map the (string) keys of an
+object into variable name TE nodes without using `te.raw`. Normally you'd just
+use `` te`myVarNameHere` `` to define a variable name (as just regular code).
+
+### `te.dangerousKey(ident, forceQuotes = false)`
+
+Takes `ident` and turns it into the representation of a safely escaped
+JavaScript object key (to be used in an object definition). We do our best to
+not put quote marks around the key unless necessary (or `forceQuotes` is set),
+so that the output code is more pleasant to read.
+
+We'll throw an error if you pass an `ident` that contains unexpected characters,
+this is intended to be used with relatively straightforward strings
+(`/[$@A-Za-z0-9_.-]+$/`). We also forbid common attack vectors such as
+`__proto__`, `constructor`, `hasOwnProperty`, etc. (For the full list, evaluate
+`Object.getOwnPropertyNames(Object.prototype)`.)
+
+**IMPORTANT**: It's strongly recommended that instead of defining an object via
+`const obj = { ${te.dangerousKey(untrustedKey)}: value }` you instead use
+`const obj = Object.create(null);` and then set the properties on the resulting
+object via `${obj}[${te.lit(untrustedKey)}] = value;` - this prevents attacks
+such as **prototype polution** since properties like `__proto__` are not special
+on null-prototype objects, whereas they can cause havok in regular `{}` objects.
+
+### `te.get(key)`
+
+Returns an expression for accessing the property `key` (which could be a string,
+symbol or number) of the preceding expression; will return code like `.foo` or
+`["foo"]` as appropriate.
+
+### `te.optionalGet(key)`
+
+As with `te.get` except using optional chaining - the expression will be `?.foo`
+or `?.["foo"]` as appropriate.
+
+### `te.set(key, hasNullPrototype)`
+
+As with `te.get`, except since it's for setting a key we'll perform checks to
+ensure you're not writing to unsafe keys (such as `__proto__`) unless you
+specify that `hasNullPrototype` is true (because any key can bet written safely
+to `Object.create(null)`).
+
+### `te.tempVar(symbol = Symbol())`
+
+**EXPERIMENTAL**
+
+Creates a temporary variable (or returns the existing temp var if the same
+symbol is passed again) that can be used in expressions and statements.
+
+### `te.tmp(obj, callback)`
+
+(**ADVANCED**)
+
+If `obj` is potentially expensive code and you need to reference it multiple
+times (e.g. `` te`(${obj}.foo === 3 ? ${obj}.bar : ${obj}.baz)`  ``) then you
+can use `tmp` to create a temporary variable that stores reference to it and
+return the result of calling `callback` passing this temporary reference. E.g.
+`` te.tmp(obj, tmp => te`(${tmp}.foo === 3 ? ${tmp}.bar : ${tmp}.baz)`) `` means
+that the potentially expensive expression in the original `obj` variable only
+need to be evaluated once, not 3 times.
+
+### `te.run(fragment)` (alias: eval)
+
+Evaluates the TE fragment and returns the result.
+
+```js
+const fragment = te`return 1 + 2`;
+const result = te.run(fragment);
+// result = 3;
+```
+
+### `te.compile(fragment)`
+
+Builds the TE fragment into a string ready to be evaluated, but does not
+evaluate it. Returns an object containing the `string` and any `refs`. Useful
+for debugging, or tests.
+
+```js
+const fragment = te`return ${te.ref(1)} + ${te.ref(2)}`;
+const result = te.compile(fragment);
+// result = { string: `return _$_ref1 + _$_ref2`, refs: { _$_ref1: 1, _$_ref2: 2 } }
+```

package/dist/index.d.ts

@@ -0,0 +1,198 @@
+import { reservedWords } from "./reservedWords.js";
+/**
+ * This is the secret to our safety; since this is a symbol it cannot be faked
+ * in a JSON payload and it cannot be constructed with a new Symbol (even with
+ * the same argument), so external data cannot make itself trusted.
+ */
+declare const $$type: unique symbol;
+/**
+ * Represents raw TE, the text will be output verbatim into the compiled code.
+ */
+export interface TERawNode {
+    readonly [$$type]: "RAW";
+    /** text */
+    readonly t: string;
+}
+/**
+ * Represents an TE value that will be replaced with a closure variable in the
+ * compiled TE statement.
+ */
+export interface TERefNode {
+    readonly [$$type]: "REF";
+    /** value */
+    readonly v: any;
+}
+export interface TETemporaryVariableNode {
+    readonly [$$type]: "VARIABLE";
+    /** symbol */
+    readonly s: symbol;
+}
+/**
+ * Represents that the TE inside this should be indented when pretty printed.
+ */
+export interface TEIndentNode {
+    readonly [$$type]: "INDENT";
+    /** content */
+    readonly c: TEQuery;
+}
+/** @internal */
+export declare type TENode = TERawNode | TERefNode | TETemporaryVariableNode | TEIndentNode;
+/** @internal */
+export interface TEQuery {
+    readonly [$$type]: "QUERY";
+    /** nodes */
+    readonly n: ReadonlyArray<TENode>;
+}
+/**
+ * Representation of TE, identifiers, values, etc; to generate a query that
+ * can be issued to the database it needs to be fed to `te.compile`.
+ */
+export declare type TE = TENode | TEQuery;
+declare function isTE(node: unknown): node is TE;
+/**
+ * Accepts an te`...` expression and compiles it out to TE text with
+ * placeholders, and the values to substitute for these values.
+ */
+declare function compile(fragment: TE): {
+    string: string;
+    refs: {
+        [key: string]: any;
+    };
+};
+/**
+ * Creates a TE item for a raw code string. Just plain ol‘ raw code. This
+ * method is dangerous though because it involves no escaping, so proceed with
+ * caution! It's very very rarely warranted - there is likely a safer way of
+ * achieving your goal. DO NOT USE THIS WITH UNTRUSTED INPUT!
+ */
+declare function raw(text: string): TE;
+/**
+ * Creates a TE item for a value that will be included in our final query.
+ * This value will be added in a way which avoids TE injection.
+ */
+declare function ref(val: any): TE;
+declare const undefinedNode: TERawNode;
+export declare function stringifyString(value: string): string;
+export declare const toJSON: (value: any) => string;
+/**
+ * If the value is simple will inline it into the query, otherwise will defer
+ * to `te.ref`.
+ */
+declare function lit(val: any): TE;
+/**
+ * If you're building a string and you want to inject untrusted content into it
+ * without opening yourself to code injection attacks, this is the method for
+ * you. Example:
+ *
+ * ```js
+ * const code = te`const str = "abc${te.substring(untrusted, '"')}123";`
+ * ```
+ */
+declare function substring(text: string, stringType: "'" | '"' | "`"): TE;
+/**
+ * Escapes `content` so that it can be safely embedded in a multiline comment.
+ */
+declare function subcomment(content: string | number | null | undefined): TERawNode;
+/**
+ * Is safe to set as the key of a POJO (without a null prototype).
+ */
+export declare const isSafeObjectPropertyName: (key: string | symbol | number) => boolean;
+/**
+ * Can represent as an identifier rather than a string key
+ *
+ * @remarks
+ * Doesn't allow it to start with two underscores.
+ */
+export declare const canRepresentAsIdentifier: (key: string | symbol | number) => key is string | number;
+declare function identifier(name: string): TERawNode;
+/**
+ * IMPORTANT: It's strongly recommended that instead of defining an object via
+ * `const obj = { ${te.dangerousKey(untrustedKey)}: value }` you instead use
+ * `const obj = Object.create(null);` and then set the properties on the resulting
+ * object via `${obj}[${te.lit(untrustedKey)}] = value;` - this prevents attacks such as
+ * **prototype polution** since properties like `__proto__` are not special on
+ * null-prototype objects, whereas they can cause havok in regular `{}` objects.
+ */
+declare function dangerousKey(key: string | symbol | number): TE;
+/**
+ * Accesses the key of an object either via `.` or `[]` as appropriate;
+ * `obj${te.get(key)}` would become `obj.foo` or `obj["1foo"]` as
+ * appropriate.
+ */
+declare function get(key: string | symbol | number): TE;
+/**
+ * Accesses the key of an object via optional-chaining:
+ * `obj${te.optionalGet(key)}` would become `obj?.foo` or `obj?.["1foo"]` as
+ * appropriate.
+ */
+declare function optionalGet(key: string | symbol | number): TE;
+/**
+ * Sets the key of an object either via `.` or `[]` as appropriate;
+ * `obj${te.set(key)}` would become `obj.foo` or `obj["1foo"]` as
+ * appropriate.
+ *
+ * If the object you're setting properties on has a `null` prototype
+ * (`Object.create(null)`) then you can set `hasNullPrototype` to true and all
+ * keys are allowed. If this is not the case, then an error will be thrown on
+ * certain potentially dangerous keys such as `__proto__` or `constructor`.
+ */
+declare function set(key: string | symbol | number, hasNullPrototype?: boolean): TE;
+/**
+ * @experimental
+ */
+declare function tempVar(symbol?: symbol): TE;
+declare function tmp(obj: TE, callback: (tmp: TE) => TE): TE;
+declare function run<TResult>(fragment: TE): TResult;
+declare function run<TResult>(strings: TemplateStringsArray, ...values: TE[]): TResult;
+/**
+ * Join some TE items together, optionally separated by a string. Useful when
+ * dealing with lists of TE items, for example a dynamic list of columns or
+ * variadic TE function arguments.
+ */
+declare function join(items: Array<TE>, separator?: string): TE;
+/**
+ * WARNING: all lines will be indented, without any parsing, so if there are
+ * template literals that contain newlines, spaces will be added inside these
+ * too.
+ */
+declare function indent(fragment: TE): TE;
+declare function indent(strings: TemplateStringsArray, ...values: Array<TE>): TE;
+declare function indentIf(condition: boolean, fragment: TE): TE;
+declare const te: TamedEvil;
+export default te;
+export { compile, dangerousKey, run as eval, get, identifier, isTE, join, lit, lit as literal, optionalGet, ref, reservedWords, run, set, subcomment, substring, te, tempVar, tmp, undefinedNode as undefined, raw, };
+export interface TamedEvil {
+    (strings: TemplateStringsArray, ...values: Array<TE>): TE;
+    te: TamedEvil;
+    ref: typeof ref;
+    reference: typeof ref;
+    lit: typeof lit;
+    literal: typeof lit;
+    substring: typeof substring;
+    subcomment: typeof subcomment;
+    join: typeof join;
+    identifier: typeof identifier;
+    dangerousKey: typeof dangerousKey;
+    get: typeof get;
+    optionalGet: typeof optionalGet;
+    set: typeof set;
+    tmp: typeof tmp;
+    tempVar: typeof tempVar;
+    run: {
+        <TResult>(fragment: TE): TResult;
+        <TResult>(strings: TemplateStringsArray, ...values: TE[]): TResult;
+    };
+    eval: {
+        <TResult>(fragment: TE): TResult;
+        <TResult>(strings: TemplateStringsArray, ...values: TE[]): TResult;
+    };
+    compile: typeof compile;
+    indent: typeof indent;
+    indentIf: typeof indentIf;
+    undefined: TE;
+    blank: TE;
+    isTE: typeof isTE;
+    reservedWords: typeof reservedWords;
+    raw: typeof raw;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}