@bockit/sequel 0.0.0-stage → 0.1.0

package/dist/generator/main.js

@@ -0,0 +1,12 @@
+// sqlc runs this as its process plugin, through the per-run wrapper `src/generate/` writes
+// (R1). It reads nothing but stdin, and ignores its one argument.
+import { runPlugin } from './plugin.js';
+const chunks = [];
+for await (const chunk of process.stdin)
+    chunks.push(chunk);
+const { stdout, stderr, exitCode } = runPlugin(Buffer.concat(chunks).toString('utf8'));
+if (stdout !== '')
+    process.stdout.write(stdout);
+if (stderr !== '')
+    process.stderr.write(stderr);
+process.exitCode = exitCode;

package/dist/generator/pg-array-helper.d.ts

@@ -0,0 +1,2 @@
+export declare const HELPER_NAME = "parsePgArray";
+export declare const PG_ARRAY_HELPER = "function parsePgArray(value: unknown): any {\n  if (typeof value !== 'string') {\n    return value\n  }\n  const text = value\n  let pos = text.indexOf('{')\n  if (pos === -1) {\n    return []\n  }\n  const parse = (): unknown[] => {\n    const items: unknown[] = []\n    pos++\n    while (pos < text.length) {\n      const char = text.charAt(pos)\n      if (char === '}') {\n        pos++\n        return items\n      }\n      if (char === ',') {\n        pos++\n      } else if (char === '{') {\n        items.push(parse())\n      } else if (char === '\"') {\n        let item = ''\n        pos++\n        while (pos < text.length && text.charAt(pos) !== '\"') {\n          if (text.charAt(pos) === '\\\\') {\n            pos++\n          }\n          item += text.charAt(pos)\n          pos++\n        }\n        pos++\n        items.push(item)\n      } else {\n        const start = pos\n        while (pos < text.length && text.charAt(pos) !== ',' && text.charAt(pos) !== '}') {\n          pos++\n        }\n        const item = text.slice(start, pos)\n        items.push(item === 'NULL' ? null : item)\n      }\n    }\n    return items\n  }\n  return parse()\n}\n";

package/dist/generator/pg-array-helper.js

@@ -0,0 +1,53 @@
+// The name reserved for the helper, whether or not a module uses it (R17).
+export const HELPER_NAME = 'parsePgArray';
+// §13: parses Postgres's array output format, for the array types pg-types returns as text.
+// The text is fixed: every module that needs it emits these same bytes (R50). It compiles
+// under the settings of R15, and every loop advances or returns, so it terminates on any input.
+export const PG_ARRAY_HELPER = `function parsePgArray(value: unknown): any {
+  if (typeof value !== 'string') {
+    return value
+  }
+  const text = value
+  let pos = text.indexOf('{')
+  if (pos === -1) {
+    return []
+  }
+  const parse = (): unknown[] => {
+    const items: unknown[] = []
+    pos++
+    while (pos < text.length) {
+      const char = text.charAt(pos)
+      if (char === '}') {
+        pos++
+        return items
+      }
+      if (char === ',') {
+        pos++
+      } else if (char === '{') {
+        items.push(parse())
+      } else if (char === '"') {
+        let item = ''
+        pos++
+        while (pos < text.length && text.charAt(pos) !== '"') {
+          if (text.charAt(pos) === '\\\\') {
+            pos++
+          }
+          item += text.charAt(pos)
+          pos++
+        }
+        pos++
+        items.push(item)
+      } else {
+        const start = pos
+        while (pos < text.length && text.charAt(pos) !== ',' && text.charAt(pos) !== '}') {
+          pos++
+        }
+        const item = text.slice(start, pos)
+        items.push(item === 'NULL' ? null : item)
+      }
+    }
+    return items
+  }
+  return parse()
+}
+`;

package/dist/generator/plugin.d.ts

@@ -0,0 +1,6 @@
+export type PluginOutput = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};
+export declare function runPlugin(input: string): PluginOutput;

package/dist/generator/plugin.js

@@ -0,0 +1,26 @@
+import { generate } from './generate.js';
+import { readRequest } from './request.js';
+// R2–R6: a JSON GenerateRequest in, a JSON GenerateResponse out. On failure, nothing on
+// stdout, every failure on stderr one per line, and exit 1.
+export function runPlugin(input) {
+    let result;
+    try {
+        result = generate(readRequest(JSON.parse(input)));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            stdout: '',
+            stderr: `sequel's generator could not read sqlc's request: ${message}\n`,
+            exitCode: 1,
+        };
+    }
+    if (!result.ok) {
+        return { stdout: '', stderr: result.failures.map((line) => `${line}\n`).join(''), exitCode: 1 };
+    }
+    const files = result.files.map((file) => ({
+        name: file.name,
+        contents: Buffer.from(file.contents, 'utf8').toString('base64'),
+    }));
+    return { stdout: JSON.stringify({ files }), stderr: '', exitCode: 0 };
+}

package/dist/generator/request.d.ts

@@ -0,0 +1,57 @@
+export type Identifier = {
+    catalog: string;
+    schema: string;
+    name: string;
+};
+export type Column = {
+    name: string;
+    not_null: boolean;
+    is_array: boolean;
+    is_func_call: boolean;
+    is_sqlc_slice: boolean;
+    type: Identifier | null;
+    embed_table: Identifier | null;
+    array_dims: number;
+};
+export type Parameter = {
+    number: number;
+    column: Column | null;
+};
+export type Query = {
+    text: string;
+    name: string;
+    cmd: string;
+    columns: Column[];
+    params: Parameter[];
+    comments: string[];
+    filename: string;
+};
+export type Table = {
+    rel: Identifier | null;
+    columns: {
+        name: string;
+        not_null: boolean;
+    }[];
+};
+export type Schema = {
+    name: string;
+    tables: Table[];
+    enums: {
+        name: string;
+        vals: string[];
+    }[];
+};
+export type Catalog = {
+    default_schema: string;
+    schemas: Schema[];
+};
+export type GenerateRequest = {
+    catalog: Catalog | null;
+    queries: Query[];
+    plugin_options: string;
+};
+export type BigintMode = 'string' | 'number' | 'bigint';
+export type Options = {
+    bigint: BigintMode;
+};
+export declare function readRequest(value: unknown): GenerateRequest;

package/dist/generator/request.js

@@ -0,0 +1,96 @@
+// The parts of sqlc's `GenerateRequest` the generator reads (R2). sqlc encodes it with
+// protobuf's JSON mapping, using the proto field names, so a query's parameters are under
+// `params`. Every field is present, absent messages are `null`, and `bytes` are base64.
+// Reads the request leniently: a missing field takes its protobuf default, so hand-built
+// requests in tests can leave out what they don't need.
+export function readRequest(value) {
+    const request = record(value);
+    const catalog = request.catalog === null || request.catalog === undefined ? null : record(request.catalog);
+    return {
+        catalog: catalog === null
+            ? null
+            : {
+                default_schema: string(catalog.default_schema),
+                schemas: list(catalog.schemas).map((value) => {
+                    const schema = record(value);
+                    return {
+                        name: string(schema.name),
+                        tables: list(schema.tables).map((value) => {
+                            const table = record(value);
+                            return {
+                                rel: identifier(table.rel),
+                                columns: list(table.columns).map((value) => {
+                                    const column = record(value);
+                                    return { name: string(column.name), not_null: column.not_null === true };
+                                }),
+                            };
+                        }),
+                        enums: list(schema.enums).map((value) => {
+                            const item = record(value);
+                            return { name: string(item.name), vals: list(item.vals).map(string) };
+                        }),
+                    };
+                }),
+            },
+        queries: list(request.queries).map((value) => {
+            const query = record(value);
+            return {
+                text: string(query.text),
+                name: string(query.name),
+                cmd: string(query.cmd),
+                columns: list(query.columns).map(column),
+                params: list(query.params).map((value) => {
+                    const parameter = record(value);
+                    return {
+                        number: typeof parameter.number === 'number' ? parameter.number : 0,
+                        column: parameter.column === null || parameter.column === undefined
+                            ? null
+                            : column(parameter.column),
+                    };
+                }),
+                comments: list(query.comments).map(string),
+                filename: string(query.filename),
+            };
+        }),
+        plugin_options: string(request.plugin_options),
+    };
+}
+function column(value) {
+    const item = record(value);
+    return {
+        name: string(item.name),
+        not_null: item.not_null === true,
+        is_array: item.is_array === true,
+        is_func_call: item.is_func_call === true,
+        is_sqlc_slice: item.is_sqlc_slice === true,
+        type: identifier(item.type),
+        embed_table: identifier(item.embed_table),
+        array_dims: typeof item.array_dims === 'number' ? item.array_dims : 0,
+    };
+}
+function identifier(value) {
+    if (value === null || value === undefined)
+        return null;
+    const item = record(value);
+    return { catalog: string(item.catalog), schema: string(item.schema), name: string(item.name) };
+}
+function record(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error('the GenerateRequest is malformed: expected an object');
+    }
+    return value;
+}
+function list(value) {
+    if (value === null || value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error('the GenerateRequest is malformed: expected an array');
+    return value;
+}
+function string(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value !== 'string')
+        throw new Error('the GenerateRequest is malformed: expected a string');
+    return value;
+}

package/dist/generator/select-list.d.ts

@@ -0,0 +1,27 @@
+import { type Token } from './lexer.ts';
+export type FromItem = {
+    table: {
+        schema: string | null;
+        name: string;
+    } | null;
+    alias: string | null;
+    nullable: boolean;
+};
+export type SelectList = {
+    items: Token[][] | null;
+    from: FromItem[] | null;
+};
+export declare function selectList(text: string, columnCount: number): SelectList;
+export type Expression = {
+    tokens: Token[];
+    depth: number;
+};
+export declare function bare(item: Token[]): Expression;
+export declare function isNeverNullCall(item: Token[]): boolean;
+export declare function coalesce(item: Token[]): 'never-null' | 'nullable' | null;
+export declare function isNullTest(item: Token[]): boolean;
+export type ColumnLookup = (table: {
+    schema: string | null;
+    name: string;
+}, column: string) => 'not-null' | 'nullable' | 'missing' | null;
+export declare function arrayAggElementsNotNull(item: Token[], from: FromItem[] | null, lookup: ColumnLookup): boolean;