@dudousxd/nestjs-catalog 0.14.0 → 0.15.0

package/dist/catalog.controller.js

@@ -13,8 +13,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCatalogController = createCatalogController;
+const node_stream_1 = require("node:stream");
 const common_1 = require("@nestjs/common");
-const catalog_query_cache_1 = require("./catalog.query-cache");
+const catalog_csv_1 = require("./catalog.csv");
 const catalog_registry_base_1 = require("./catalog.registry.base");
 const catalog_route_auth_1 = require("./catalog.route-auth");
 const catalog_service_1 = require("./catalog.service");
@@ -274,17 +275,60 @@ function createCatalogController(path, guards, decorators = []) {
             return this.service.runSavedQuery(id, body?.maxRows);
         }
         /**
-         * The same result as CSV.
+         * The same result as CSV, written out as the rows arrive.
          *
          * A GET, not a POST, so it can be a plain link — a download that only works
          * from JavaScript cannot be pasted into a mail or a scheduled job.
+         *
+         * **Nothing here holds the file.** This used to run the query, hold the
+         * result, build the whole CSV string and then answer — which is the shape
+         * that made a 981,469-row connector load never finish, and it is worse on an
+         * export than on a load, because an export has no row cap by design. Now
+         * `streamSavedQuery` hands over rows, {@link csvLines} turns each into a
+         * line, and the response is written from that.
+         *
+         * **`@Res({ passthrough: true })` is still right, and the returned value is
+         * what had to change.** Passthrough means "I am setting headers, you send
+         * the body", and that is exactly what this handler wants. What it must not
+         * return any more is a string: the express adapter answers a string body
+         * with `res.send()`, which sets `content-length` — and a length header is a
+         * promise about a body nobody has counted yet. A `StreamableFile` is the
+         * body shape the adapter pipes instead, and `applyStreamHeaders` sets a
+         * length only when the `StreamableFile` was given one, which this is not. So
+         * the response is chunked and carries no `content-length`. Taking the
+         * response over with a bare `@Res()` and pumping it by hand would work too,
+         * and would name a platform: this package peer-depends on `@nestjs/common`
+         * and `@nestjs/core` and on no adapter, so a hand-written `write`/`drain`
+         * loop would be one adapter's API written into a library that deliberately
+         * does not have one. A `StreamableFile` leaves the piping to whichever
+         * adapter the host mounted.
+         *
+         * The pipe is also what bounds the memory: `Readable.from` stops pulling
+         * from the generator once its buffer is full, the pipe stops reading once
+         * the socket says wait, and the generator stops pulling from the store. A
+         * client that reads slowly slows the database read down rather than filling
+         * this process with the rows it has not collected.
          */
         async exportSavedQuery(id, response) {
-            const { savedQuery, result } = await this.service.runSavedQuery(id);
+            const { savedQuery, columns, rows } = await this.service.streamSavedQuery(id);
             const filename = `${savedQuery.name.replace(/[^A-Za-z0-9_-]+/g, '-')}.csv`;
             response.setHeader('content-type', 'text/csv; charset=utf-8');
             response.setHeader('content-disposition', `attachment; filename="${filename}"`);
-            return (0, catalog_query_cache_1.toCsv)(result);
+            // Byte mode rather than object mode, so the readable's own high-water mark
+            // is measured in bytes: the lines coalesce into socket-sized writes on
+            // their way out, instead of one write per row for however many rows the
+            // table has.
+            const file = node_stream_1.Readable.from((0, catalog_csv_1.csvLines)(rows, columns), { objectMode: false });
+            // `pipe` unpipes a dead destination and leaves the SOURCE alone, which
+            // here means an operator who closes the download tab leaves this generator
+            // parked mid-`yield` — and with it, in the shipped MySQL store, an open
+            // read-only transaction on a pooled connection, for the life of the
+            // process. Destroying the readable is what calls the generator's `return`,
+            // which is what runs the `finally` the store put its rollback in. Fires on
+            // an ordinary completion too, where destroying a finished stream is a
+            // no-op.
+            response.on('close', () => file.destroy());
+            return new common_1.StreamableFile(file);
         }
         /**
          * Every SQL this query has ever been, newest first.

package/dist/catalog.csv.d.ts

@@ -0,0 +1,89 @@
+/**
+ * CSV, for the export button.
+ *
+ * Two things here are not the obvious implementation, and both are here because
+ * the obvious one was wrong in production.
+ *
+ * **Rows are written as they arrive.** {@link csvLines} is a generator over an
+ * async row source, so the caller can hand each line to a socket and never hold
+ * the file. The buffered {@link toCsv} is still exported — it is public API and
+ * a caller with a result already in memory has nothing to gain from a stream —
+ * but it is now the special case rather than the only shape.
+ *
+ * **A cell that a spreadsheet would run is neutralised.** See
+ * {@link guardFormula}.
+ */
+/** One row of a result, as every store hands it over. */
+export type CsvRow = Record<string, unknown>;
+/**
+ * Stop a cell being executed when the file is opened.
+ *
+ * A CSV is not a document format, it is a program that a spreadsheet is willing
+ * to run. A cell whose value begins with one of {@link FORMULA_LEADERS} is
+ * evaluated on open, and the values in this file come from whatever the queried
+ * source contained — which for this catalog is other people's operational data,
+ * loaded by connectors, from systems nobody here controls. So the crafted cell
+ * is not a thought experiment: it is one row in a table an operator exports and
+ * opens.
+ *
+ * **The escape is a leading apostrophe, and it is not free.** Excel and Sheets
+ * both read `'` as "the rest is literal text" and do not show it in the cell;
+ * every other reader on earth — a parser, a `pandas.read_csv`, the next
+ * pipeline that ingests this export — sees an apostrophe that was not in the
+ * source. That is a real corruption, and it is why the guard is not applied to
+ * every cell that merely starts with a leader.
+ *
+ * **So a value that is plainly a number is left exactly as it was.** `-42` is
+ * not an injection vector: a spreadsheet evaluates it to the number -42, which
+ * is what it already was. Exempting it is what lets a machine read this file
+ * back and still get -42, and it costs no safety, because the population being
+ * defended against — `=`, `@`, an operator followed by anything that is not a
+ * number — is disjoint from it. Everything outside the exemption gets the
+ * apostrophe and reads differently to a parser than it did to the database.
+ * That trade is deliberate: a wrong apostrophe is a data-quality bug somebody
+ * can see, and a formula is code running on the machine of whoever opened the
+ * file.
+ *
+ * The apostrophe goes at position 0, in front of any leading blank, because
+ * that is the only position a spreadsheet honours it in.
+ */
+export declare function guardFormula(text: string): string;
+/**
+ * One cell, ready to sit in a row.
+ *
+ * Order matters and is the second thing people get wrong. The formula guard
+ * runs on the raw text, and the CSV quoting runs on the result — so a value that
+ * needs both comes out as `"'=1+1,x"`, with the apostrophe INSIDE the quotes and
+ * applied once. Doing it the other way round would put the apostrophe outside
+ * the quoting and produce a field no CSV reader can parse; doing it twice would
+ * put two apostrophes in a cell that needed one.
+ */
+export declare function csvCell(value: unknown): string;
+/**
+ * A CSV file, one line at a time, from a source that hands rows over as it has
+ * them.
+ *
+ * Each yield is a complete line including its terminator, so a consumer can
+ * write it and forget it. Nothing accumulates here: the generator holds one row
+ * and the column list, whatever the source is doing, which is the whole point —
+ * an export has no row cap by design, so the only bound available is that no
+ * stage keeps more than it is using.
+ *
+ * `columns` may be omitted, and then the header is taken from the keys of the
+ * first row — the same rule the buffered read uses, applied at the only moment a
+ * stream can apply it. A source that knows its columns up front should pass
+ * them, because it is the only way an empty result gets a header row at all.
+ */
+export declare function csvLines(rows: AsyncIterable<CsvRow>, columns?: readonly string[]): AsyncGenerator<string>;
+/**
+ * The whole file as a string.
+ *
+ * Kept because it is public API and because a caller holding a finished result
+ * gains nothing from a stream. It is NOT what the export route uses — see
+ * {@link csvLines} — and a caller reaching for it with an unbounded result is
+ * choosing to hold the file.
+ */
+export declare function toCsv(result: {
+    columns: string[];
+    rows: CsvRow[];
+}): string;

package/dist/catalog.csv.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * CSV, for the export button.
+ *
+ * Two things here are not the obvious implementation, and both are here because
+ * the obvious one was wrong in production.
+ *
+ * **Rows are written as they arrive.** {@link csvLines} is a generator over an
+ * async row source, so the caller can hand each line to a socket and never hold
+ * the file. The buffered {@link toCsv} is still exported — it is public API and
+ * a caller with a result already in memory has nothing to gain from a stream —
+ * but it is now the special case rather than the only shape.
+ *
+ * **A cell that a spreadsheet would run is neutralised.** See
+ * {@link guardFormula}.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guardFormula = guardFormula;
+exports.csvCell = csvCell;
+exports.csvLines = csvLines;
+exports.toCsv = toCsv;
+/**
+ * The characters a spreadsheet reads as "what follows is a formula".
+ *
+ * `=` is the obvious one. `+`, `-` and `@` are the ones people forget: Excel and
+ * Sheets both accept a leading `+` or `-` as the start of an expression, and `@`
+ * introduces a function reference. `-2+3+cmd|' /C calc'!A0` is a working command
+ * execution in an unpatched Excel, and it starts with a minus sign.
+ */
+const FORMULA_LEADERS = new Set(['=', '+', '-', '@']);
+/**
+ * Blank a spreadsheet strips before it decides whether a cell is a formula.
+ *
+ * The reason this exists rather than a plain `text[0]` test: importers do not
+ * agree on whether leading blank is part of the value. Several strip it and then
+ * dispatch on what is left, so `  =1+1` is a formula to them and an innocent
+ * string to a guard that only looked at position zero. Guarding the stripped
+ * form costs nothing on values that were never formulas.
+ */
+const LEADING_BLANK = /^[\t\n\v\f\r  ]+/;
+/**
+ * A value a spreadsheet will read back as the number it already is.
+ *
+ * This is the exemption that keeps the guard from corrupting data — see
+ * {@link guardFormula}. Deliberately narrow: an optional sign, digits with at
+ * most one point, an optional exponent, and nothing else. `-42` matches.
+ * `-42abc` does not, `- 42` does not, and `-2+3+cmd|' /C calc'!A0` does not.
+ */
+const PLAIN_NUMBER = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+/**
+ * Stop a cell being executed when the file is opened.
+ *
+ * A CSV is not a document format, it is a program that a spreadsheet is willing
+ * to run. A cell whose value begins with one of {@link FORMULA_LEADERS} is
+ * evaluated on open, and the values in this file come from whatever the queried
+ * source contained — which for this catalog is other people's operational data,
+ * loaded by connectors, from systems nobody here controls. So the crafted cell
+ * is not a thought experiment: it is one row in a table an operator exports and
+ * opens.
+ *
+ * **The escape is a leading apostrophe, and it is not free.** Excel and Sheets
+ * both read `'` as "the rest is literal text" and do not show it in the cell;
+ * every other reader on earth — a parser, a `pandas.read_csv`, the next
+ * pipeline that ingests this export — sees an apostrophe that was not in the
+ * source. That is a real corruption, and it is why the guard is not applied to
+ * every cell that merely starts with a leader.
+ *
+ * **So a value that is plainly a number is left exactly as it was.** `-42` is
+ * not an injection vector: a spreadsheet evaluates it to the number -42, which
+ * is what it already was. Exempting it is what lets a machine read this file
+ * back and still get -42, and it costs no safety, because the population being
+ * defended against — `=`, `@`, an operator followed by anything that is not a
+ * number — is disjoint from it. Everything outside the exemption gets the
+ * apostrophe and reads differently to a parser than it did to the database.
+ * That trade is deliberate: a wrong apostrophe is a data-quality bug somebody
+ * can see, and a formula is code running on the machine of whoever opened the
+ * file.
+ *
+ * The apostrophe goes at position 0, in front of any leading blank, because
+ * that is the only position a spreadsheet honours it in.
+ */
+function guardFormula(text) {
+    if (text.length === 0)
+        return text;
+    // A literal tab or carriage return in first position is itself treated as a
+    // leader by some importers, which strip it and evaluate what follows.
+    const leadingControl = text[0] === '\t' || text[0] === '\r';
+    const body = text.replace(LEADING_BLANK, '');
+    if (body.length === 0)
+        return text;
+    if (!leadingControl && !FORMULA_LEADERS.has(body[0]))
+        return text;
+    return PLAIN_NUMBER.test(body) ? text : `'${text}`;
+}
+/**
+ * One cell, ready to sit in a row.
+ *
+ * Order matters and is the second thing people get wrong. The formula guard
+ * runs on the raw text, and the CSV quoting runs on the result — so a value that
+ * needs both comes out as `"'=1+1,x"`, with the apostrophe INSIDE the quotes and
+ * applied once. Doing it the other way round would put the apostrophe outside
+ * the quoting and produce a field no CSV reader can parse; doing it twice would
+ * put two apostrophes in a cell that needed one.
+ */
+function csvCell(value) {
+    if (value === null || value === undefined)
+        return '';
+    const text = typeof value === 'object' ? JSON.stringify(value) : String(value);
+    const guarded = guardFormula(text);
+    // Quote when the value could otherwise break the row apart. Doubling the
+    // quote is the CSV escape, not a backslash.
+    return /[",\n\r]/.test(guarded) ? `"${guarded.replace(/"/g, '""')}"` : guarded;
+}
+/** CRLF: Excel still treats a bare LF file as one long row in some locales. */
+const EOL = '\r\n';
+function csvLine(cells) {
+    return `${cells.join(',')}${EOL}`;
+}
+/**
+ * A CSV file, one line at a time, from a source that hands rows over as it has
+ * them.
+ *
+ * Each yield is a complete line including its terminator, so a consumer can
+ * write it and forget it. Nothing accumulates here: the generator holds one row
+ * and the column list, whatever the source is doing, which is the whole point —
+ * an export has no row cap by design, so the only bound available is that no
+ * stage keeps more than it is using.
+ *
+ * `columns` may be omitted, and then the header is taken from the keys of the
+ * first row — the same rule the buffered read uses, applied at the only moment a
+ * stream can apply it. A source that knows its columns up front should pass
+ * them, because it is the only way an empty result gets a header row at all.
+ */
+async function* csvLines(rows, columns) {
+    // A declared header goes out before the source is asked for anything, so an
+    // empty result is still a file that says which columns were empty rather than
+    // zero bytes.
+    let header = columns;
+    if (header !== undefined)
+        yield csvLine(header.map(csvCell));
+    for await (const row of rows) {
+        if (header === undefined) {
+            header = Object.keys(row);
+            yield csvLine(header.map(csvCell));
+        }
+        yield csvLine(header.map((column) => csvCell(row[column])));
+    }
+}
+/**
+ * The whole file as a string.
+ *
+ * Kept because it is public API and because a caller holding a finished result
+ * gains nothing from a stream. It is NOT what the export route uses — see
+ * {@link csvLines} — and a caller reaching for it with an unbounded result is
+ * choosing to hold the file.
+ */
+function toCsv(result) {
+    const lines = [csvLine(result.columns.map(csvCell))];
+    for (const row of result.rows) {
+        lines.push(csvLine(result.columns.map((column) => csvCell(row[column]))));
+    }
+    return lines.join('');
+}

package/dist/catalog.filters.d.ts

@@ -50,10 +50,14 @@ export declare function filterOperatorTakesValue(operator: CatalogFilterOperator
 export interface CatalogObjectFilter {
     /**
      * The property's `name`, which is its identity in the type — never its
-     * `columnName`. On a published type the two differ whenever the source spelled
-     * a column in a way SQL cannot: `Asset Id` arrives as `columnName` and the
-     * property is `Asset_Id`. Filtering by the source spelling would resolve to no
-     * property at all on every one of them.
+     * `columnName`, and never the column the view exposes.
+     *
+     * Three names can be in play for one field and only this one identifies it: a
+     * property called `Asset Id` is stored in a column called `Asset_Id`, is
+     * exposed by the SQL console under `Asset_Id`, and may carry any `columnName`
+     * its publisher chose. A filter naming any of the others resolves to no
+     * property at all. The store is what translates this into a column, which is
+     * the only place that translation belongs.
      */
     property: string;
     op: CatalogFilterOperator;

package/dist/catalog.identifiers.d.ts

@@ -0,0 +1,161 @@
+/**
+ * How a name becomes a column, and what it has to look like by the end.
+ *
+ * Two rules, and they are here together because neither is usable without the
+ * other. {@link physicalColumn} is the *cleaning* — the lossy map from a
+ * property's name to the column a store creates for it. {@link isSafeIdentifier}
+ * is the *character set* the result of that cleaning has to be in. What a
+ * publisher is actually promised is the composition: a name may be spelled
+ * however the source spells it, and what the cleaning produces has to be
+ * something a store can write.
+ *
+ * Identifiers themselves are *rejected*, never escaped. Every table and column
+ * name a store emits arrives from another application over HTTP and ends up in
+ * DDL and in SELECT lists, where no placeholder can stand in for it, so anything
+ * outside this character set never becomes SQL at all.
+ *
+ * It is part of what the catalog promises a *publisher*. Refuse a property name
+ * and the sentence explaining why is the only statement of the rule most people
+ * will ever read, so it belongs to the contract rather than to whichever adapter
+ * happens to be mounted.
+ *
+ * And for one more reason. It used to be two copies — `store-mikro-orm` and
+ * `store-clickhouse` each carried this pattern and this sentence, byte for byte
+ * — and the publish-time refusal in the pipeline package borrowed the MySQL one
+ * so that publish-time and DDL-time could not disagree about the character set,
+ * the length or the wording. That bought the guarantee for a MySQL deployment
+ * and left a ClickHouse-only one trusting two files to be edited together. One
+ * definition is the guarantee; two identical ones are a habit.
+ *
+ * ---
+ *
+ * **Why this is its own module, and why it imports nothing.**
+ *
+ * All of this used to live in `catalog.store.ts`, which is still where every
+ * server-side caller reaches it from — that file re-exports all five names, so no
+ * import anywhere had to change. What could not stay there is the
+ * *reachability*: `catalog.store.ts` imports `BadRequestException` from
+ * `@nestjs/common` at module scope, so anything importing a **value** out of it
+ * drags NestJS along. That is fine on the server and disqualifying for
+ * `/client`, which exists precisely so a browser can share the server's rules
+ * without shipping the server.
+ *
+ * And a browser now has to be able to ask this question. A workflow template
+ * that proposes replicating a table has to know, while somebody is still
+ * choosing, whether the source's column names could be published as property
+ * names — because if they could not, the graph it would draw is refused at
+ * publish, or worse, gets "fixed" by a rename that commits nulls and reports
+ * success. Answering that from a copy of the pattern is the one thing this
+ * module's own history says not to do: the copy is what drifts, and a canvas
+ * whose idea of a legal name differs from the store's by one character is a
+ * canvas that promises a load the publisher then refuses.
+ *
+ * That is why {@link physicalColumn} had to come along rather than only
+ * {@link isSafeIdentifier}. The question a publisher is refused on is
+ * `isSafeIdentifier(physicalColumn(name))`, not `isSafeIdentifier(name)`, and a
+ * browser holding only half the composition would answer a different question
+ * from the server's — which is the same drift by another route.
+ *
+ * So the rule moved to a file with no imports, and is exported from both entry
+ * points. `validateWorkflow` set the precedent and made the same argument.
+ */
+/**
+ * Why a name cannot be written into SQL, in the words a publisher is given.
+ *
+ * One class for the whole ecosystem rather than one per adapter, so
+ * `instanceof` is a usable question across packages. The publish-time check in
+ * the pipeline package catches this to tell "that name cannot be an identifier"
+ * from "something else failed inside the store", and with a class per adapter
+ * that check would re-throw the moment the mounted store was not the one it
+ * imported — turning a 400 that names the property into a 500 that names
+ * nothing.
+ */
+export declare class UnsafeIdentifierError extends Error {
+    constructor(value: string);
+}
+/** Whether a name can be written into SQL as it stands. */
+export declare function isSafeIdentifier(value: string): boolean;
+/**
+ * Refuse a name that cannot be a SQL identifier.
+ *
+ * Throws rather than answering, because the caller's next line writes the value
+ * into a statement: a boolean that can be ignored is a boolean that eventually
+ * is. {@link isSafeIdentifier} is there for the callers that are asking rather
+ * than about to build.
+ */
+export declare function assertSafeIdentifier(value: string): void;
+/**
+ * A property's name, cleaned into the column a store can create for it.
+ *
+ * Here rather than in each adapter for the reason {@link assertSafeIdentifier}
+ * is: this is no longer only an adapter's private repair. It decides the column
+ * a load's values are written to, the column a filter is applied to, the name a
+ * committed view exposes the field under, and — since it does all of that — it
+ * decides whether a published name can work at all. The pipeline package refuses
+ * a name at publish time by asking whether *this* produces an identifier, so the
+ * refusal and the DDL have to be running the same cleaning rather than two
+ * copies of it. `store-mikro-orm` and `store-clickhouse` each carried a
+ * byte-identical private copy, and `store-mikro-orm` carried two of its own —
+ * one in `query.ts` for the view, one in `mysql-warehouse.store.ts` for
+ * everything else. Three copies of the function that decides where a column's
+ * data lives is three chances for a view to point at a column no load ever
+ * wrote.
+ *
+ * Lossy on purpose, and lossy in a way callers must handle rather than assume
+ * away: `Asset Id` and `Asset/Id` both clean to `Asset_Id`, which is what
+ * `assertNoColumnCollisions` exists to catch.
+ *
+ * 60 characters, not the 63 the identifier rule allows, and the three characters
+ * of headroom are not decorative — a store that needs to derive a second name
+ * from a column has room inside MySQL's 64-character ceiling to do it. Widening
+ * this would silently rename the column of every property whose name is 61 to 63
+ * characters long, so it stays where it is.
+ *
+ * Not every output is an identifier: `1 2 3` cleans to `1_2_3`, which no store
+ * will quote. That is not this function's business to fix — a suggestion is
+ * `toPhysicalName` in an adapter, and a refusal is `assertSafeIdentifier` on the
+ * result.
+ */
+export declare function physicalColumn(propertyName: string): string;
+/**
+ * The column name a store exposes a property under, in the committed view and
+ * in the SELECT list of a read.
+ *
+ * **Why this is not simply the property's name.** It used to be. Every store
+ * wrote `\`Asset_Id\` AS \`Asset Id\`` — the physical column reached by cleaning,
+ * the alias taken verbatim — and the alias went through `ident`, which refuses
+ * rather than escapes. So a property could only be named something that was
+ * already a SQL identifier, which meant a source column genuinely called `Asset
+ * Id` could not be published under its own spelling.
+ *
+ * That mattered far more than it looks. A load matches a source's record to a
+ * property by property NAME — the store reads `row[property.name]` — so a
+ * publisher forced to rename the property to `Asset_Id`, keeping `Asset Id` in
+ * `columnName`, was publishing a type whose every read of that field returned
+ * `undefined`. `columnName` is lineage; nothing consults it on the write path.
+ * The loads committed, the row counts were right, and the column was NULL in
+ * every row. Thirteen types were loaded that way and six of them came out with
+ * most of their columns empty — 73 of 84 on the largest, across 313,833 rows.
+ * The verbatim alias is what forced the rename, so the alias is what changed.
+ *
+ * **Why the name is still kept when it is already an identifier.** The obvious
+ * fix — always alias to {@link physicalColumn} — would rename the output column
+ * of every existing view whose property name is not equal to its own cleaned
+ * form: a property called `Asset__Id` (two underscores collapse to one) or one
+ * 61 characters long (cut to 60). Those views work today and somebody is
+ * selecting from them by name. Renaming a column under a working consumer to
+ * tidy up an inconsistency is not a trade worth making, so the rule is the
+ * narrower one: **a name that SQL can take as it stands is kept exactly; only a
+ * name SQL cannot take is cleaned.** Every view that resolves today keeps every
+ * column name it has today.
+ *
+ * **This introduces no new way for two properties to collide.** If two distinct
+ * names produce one alias then they also produce one {@link physicalColumn}, so
+ * `assertNoColumnCollisions` already refuses the pair. Both unsafe: equal
+ * aliases *are* equal physical columns. Both safe: equal aliases are equal
+ * names, and there is only one property per name. One of each — a safe `x` and
+ * an unsafe `y` with `physicalColumn(y) === x` — means `x` contains no run of
+ * underscores and is at most 60 characters, so `physicalColumn(x) === x ===
+ * physicalColumn(y)` and the columns collide too.
+ */
+export declare function outputAlias(propertyName: string): string;