@leuduan/block 0.0.0-stage → 2.0.0

package/dist/sql.js

@@ -0,0 +1,169 @@
+// Port of py/dbox/dbox/block/sql.py
+// The immutable query model (SqlSegment, Pipe, TableExpression, QueryExpression and its queries) and the `sql` tag.
+import * as l from './line.js';
+import { DEFAULT_OPTIONS } from './line.js';
+import * as h from './helpers.js';
+export function mapEntries(m) {
+    if (m instanceof Map)
+        return [...m];
+    return Object.entries(m);
+}
+// ---------------------------------------------------------------------------
+// Segments: one class each for pipes and table expressions, both just a line
+// ---------------------------------------------------------------------------
+export class SqlSegment {
+    format(options = DEFAULT_OPTIONS) {
+        return l.formatLine(this.toLine(), options);
+    }
+    toString() {
+        return this.format();
+    }
+}
+/** One `|>` step. Built by the `p` factories. */
+export class Pipe extends SqlSegment {
+    line;
+    constructor(line) {
+        super();
+        this.line = line;
+    }
+    toLine() {
+        return this.line;
+    }
+}
+/** Something that goes after FROM or JOIN. Built by the `t` factories. */
+export class TableExpression extends SqlSegment {
+    line;
+    constructor(line) {
+        super();
+        this.line = line;
+    }
+    toLine() {
+        return this.line;
+    }
+}
+// ---------------------------------------------------------------------------
+// QueryExpression — base query class
+// ---------------------------------------------------------------------------
+export class QueryExpression extends SqlSegment {
+    /** Default toTableExpression wraps in a parenthesized subquery. */
+    toTableExpression() {
+        return new TableExpression(l.paren(this.toLine()));
+    }
+}
+// ---------------------------------------------------------------------------
+// Concrete QueryExpression classes
+// ---------------------------------------------------------------------------
+export class RawQuery extends QueryExpression {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    toLine() {
+        return this.sql;
+    }
+}
+export class NamedQueryExpression extends QueryExpression {
+    name;
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+    toLine() {
+        return l.lit(this.name);
+    }
+    /** Named expressions refer to CTEs/tables — no subquery wrapping. */
+    toTableExpression() {
+        return new TableExpression(this.toLine());
+    }
+}
+class FromQuery extends QueryExpression {
+    tableExpression;
+    constructor(tableExpression) {
+        super();
+        this.tableExpression = tableExpression;
+    }
+    toLine() {
+        return l.indentNext([l.keyword('FROM'), this.tableExpression.toLine()]);
+    }
+}
+/** `FROM table`; a string is emitted as given, so quote identifiers with `t.path(id, true)` or `e.ident`. */
+export function from(tableExpression) {
+    return new FromQuery(typeof tableExpression === 'string' ? new TableExpression(l.lit(tableExpression)) : tableExpression);
+}
+export class GoogleSqlQuery extends QueryExpression {
+    ctes;
+    queryExpression;
+    orderByLine;
+    limitOffset;
+    pipes;
+    constructor({ ctes = new Map(), queryExpression, orderByLine, limitOffset, pipes = [] }) {
+        super();
+        this.ctes = ctes;
+        this.queryExpression = queryExpression;
+        this.orderByLine = orderByLine;
+        this.limitOffset = limitOffset;
+        this.pipes = pipes;
+    }
+    toLine() {
+        // A nested GoogleSqlQuery is parenthesized (query.py:126-127)
+        const queryLine = this.queryExpression instanceof GoogleSqlQuery
+            ? l.paren(this.queryExpression.toLine())
+            : this.queryExpression.toLine();
+        return l.stack([
+            this.ctes.size > 0 ? h.ctes(this.ctes) : null,
+            queryLine,
+            this.orderByLine,
+            this.limitOffset,
+            ...this.pipes.map((pipe) => pipe.toLine()),
+        ]);
+    }
+}
+/**
+ * Apply `|>` steps to a query. Pipe syntax is GoogleSQL's, so the result is a GoogleSqlQuery. A GoogleSqlQuery takes
+ * the steps on its own pipe list (only its outer wrapper is flattened); anything else is wrapped. The input is not
+ * changed.
+ */
+export function pipe(query, ...steps) {
+    if (query instanceof GoogleSqlQuery) {
+        return new GoogleSqlQuery({
+            ctes: query.ctes,
+            queryExpression: query.queryExpression,
+            orderByLine: query.orderByLine,
+            limitOffset: query.limitOffset,
+            pipes: [...query.pipes, ...steps],
+        });
+    }
+    return new GoogleSqlQuery({ queryExpression: query, pipes: steps });
+}
+/**
+ * Tagged template for raw SQL fragments.
+ * - string/number interpolations inline as raw SQL text (no quoting).
+ * - Line interpolations embed structurally (breaker recurses into them).
+ * - SqlSegment (QueryExpression etc.) interpolations use .toLine().
+ * For quoted identifiers use ident(name); for string literals use e.literalString(x).
+ */
+export function sql(strings, ...values) {
+    const parts = [];
+    strings.forEach((chunk, i) => {
+        if (chunk.length > 0)
+            parts.push(l.ensure(chunk));
+        if (i < values.length)
+            parts.push(interpToLine(values[i]));
+    });
+    const clean = parts.filter((p) => p != null);
+    if (clean.length === 0)
+        return l.lit('');
+    if (clean.length === 1)
+        return clean[0];
+    return l.combine(clean, { sep: l.BLANK });
+}
+function interpToLine(v) {
+    if (v instanceof l.Line)
+        return v;
+    if (v instanceof SqlSegment)
+        return v.toLine();
+    if (typeof v === 'number')
+        return l.lit(String(v));
+    return l.lit(v); // plain string → raw SQL fragment
+}

package/dist/t.d.ts

@@ -0,0 +1,8 @@
+import { type LineOrStr } from './line.js';
+import { type QueryExpression, TableExpression } from './sql.js';
+/** A table path; as given unless `quote`, which quotes the whole path as one identifier (see `e.ident`). */
+export declare function path(id: string, quote?: boolean): TableExpression;
+/** A query in parentheses. */
+export declare function subquery(query: QueryExpression): TableExpression;
+export declare function raw(line: LineOrStr): TableExpression;
+//# sourceMappingURL=t.d.ts.map

package/dist/t.js

@@ -0,0 +1,17 @@
+// Port of py/dbox/dbox/block/t.py
+// Table expressions: what goes after FROM or JOIN.
+import { ident } from './expr.js';
+import * as l from './line.js';
+import {} from './line.js';
+import { TableExpression } from './sql.js';
+/** A table path; as given unless `quote`, which quotes the whole path as one identifier (see `e.ident`). */
+export function path(id, quote = false) {
+    return new TableExpression(quote ? ident(id) : l.lit(id));
+}
+/** A query in parentheses. */
+export function subquery(query) {
+    return new TableExpression(l.paren(query.toLine()));
+}
+export function raw(line) {
+    return new TableExpression(l.ensure(line));
+}

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@leuduan/block",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "2.0.0",
+  "description": "SQL builder and renderer for GoogleSQL",
+  "license": "ISC",
+  "author": "Duan Leu",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "22.19.1",
+    "typescript": "^7.0.2",
+    "vitest": "4.1.5",
+    "@leuduan/tsconfig": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leuduan/luna.git",
+    "directory": "js/packages/block"
+  },
+  "scripts": {
+    "clean": "rm -rf dist tsconfig.tsbuildinfo tsconfig.build.tsbuildinfo",
+    "build": "tsc --build tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
 }