rado 1.0.7 → 1.0.8

package/dist/core/Database.d.ts

@@ -8,7 +8,6 @@ import { QueryBatch } from './Query.js';
 import { Resolver } from './Resolver.js';
 import type { Table } from './Table.js';
 export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
-    #private;
     driver: Driver;
     dialect: Dialect;
     diff: Diff;

package/dist/core/Database.js

@@ -64,7 +64,6 @@ var Database = class extends Builder {
       throw new Error("Query has parameters");
     return this.driver.exec(emitter.sql);
   }
-  #transactionLock;
   transaction(run, options = {}) {
     return this.driver.transaction(
       (inner) => {

package/dist/core/Emitter.d.ts

@@ -6,6 +6,7 @@ import { Sql } from './Sql.js';
 import type { TableApi } from './Table.js';
 import type { FieldData } from './expr/Field.js';
 import type { IncludeData } from './expr/Include.js';
+import { type JsonPath } from './expr/Json.js';
 import type { Delete } from './query/Delete.js';
 import type { Insert } from './query/Insert.js';
 import type { SelectData } from './query/Select.js';
@@ -21,7 +22,7 @@ export declare abstract class Emitter {
     abstract emitIdentifier(value: string): void;
     abstract emitValue(value: unknown): void;
     abstract emitInline(value: unknown): void;
-    abstract emitJsonPath(value: Array<number | string>): void;
+    abstract emitJsonPath(path: JsonPath): void;
     abstract emitPlaceholder(value: string): void;
     emitIdentifierOrSelf(value: string): void;
     selfName?: string;

package/dist/core/Selection.js

@@ -76,9 +76,11 @@ var Selection = class {
   #fieldNames(input, names, name) {
     const expr = getSql(input);
     if (expr) {
-      const exprName = name ?? expr.alias;
+      let exprName = name ?? expr.alias;
       if (!exprName)
         throw new Error("Missing field name");
+      while (names.has(exprName))
+        exprName = `${exprName}_`;
       return [exprName];
     }
     return Object.entries(input).flatMap(
@@ -98,7 +100,7 @@ var Selection = class {
           if (field.fieldName === exprName)
             return expr;
         }
-        return sql`${expr} as ${sql.identifier(exprName)}`;
+        return sql`${expr.forSelection()} as ${sql.identifier(exprName)}`;
       }
       return expr;
     }

package/dist/core/Sql.d.ts

@@ -3,6 +3,7 @@ import type { Emitter } from './Emitter.js';
 import { type HasSql, internalSql } from './Internal.js';
 import type { Runtime } from './MetaData.js';
 import type { FieldData } from './expr/Field.js';
+import type { JsonPath } from './expr/Json.js';
 type EmitMethods = {
     [K in keyof Emitter as K extends `emit${string}` ? K : never]: Emitter[K];
 };
@@ -31,7 +32,8 @@ export declare class Sql<Value = unknown> implements HasSql<Value> {
     value(value: unknown): Sql<Value>;
     getValue(): Value | undefined;
     inline(value: unknown): Sql<Value>;
-    jsonPath(path: Array<string | number>): Sql<Value>;
+    jsonPath(path: JsonPath): Sql<Value>;
+    forSelection(): Sql<Value>;
     placeholder(name: string): Sql<Value>;
     identifier(identifier: string): Sql<Value>;
     inlineValues(): Sql<Value>;
@@ -48,6 +50,7 @@ export declare namespace sql {
     export function placeholder<T>(name: string): Sql<T>;
     export function identifier<T>(identifier: string): Sql<T>;
     export function field<T>(field: FieldData): Sql<T>;
+    export function jsonPath<T>(path: JsonPath): Sql<T>;
     export function chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql;
     export function universal<T>(runtimes: Partial<Record<Runtime | 'default', Sql<T>>>): Sql<T>;
     type QueryChunk = HasSql | undefined;

package/dist/core/Sql.js

@@ -57,11 +57,21 @@ var Sql = class _Sql {
     return this.chunk("emitInline", value);
   }
   jsonPath(path) {
-    const last = this.#chunks.at(-1);
-    if (last?.type === "emitJsonPath")
-      last.inner.push(...path);
-    else
-      this.chunk("emitJsonPath", path);
+    const inner = path.target.#chunks[0];
+    if (inner?.type !== "emitJsonPath")
+      return this.chunk("emitJsonPath", path);
+    const innerPath = inner.inner;
+    return this.chunk("emitJsonPath", {
+      ...innerPath,
+      segments: [...innerPath.segments, ...path.segments]
+    });
+  }
+  forSelection() {
+    if (this.#chunks.length === 1) {
+      const first = this.#chunks[0];
+      if (first.type === "emitJsonPath")
+        return sql.jsonPath({ ...first.inner, asSql: false }).mapWith(this);
+    }
     return this;
   }
   placeholder(name) {
@@ -143,6 +153,10 @@ function sql(strings, ...inner) {
     return empty().field(field2);
   }
   sql2.field = field;
+  function jsonPath(path) {
+    return empty().jsonPath(path);
+  }
+  sql2.jsonPath = jsonPath;
   function chunk(type, inner) {
     return empty().chunk(type, inner);
   }

package/dist/core/expr/Json.d.ts

@@ -1,4 +1,5 @@
-import type { HasSql } from '../Internal.js';
+import { type HasSql } from '../Internal.js';
+import { type Sql } from '../Sql.js';
 import type { Input } from './Input.js';
 export interface JsonArrayHasSql<Value> extends HasSql<Array<Value>> {
     [index: number]: JsonExpr<Value>;
@@ -10,7 +11,12 @@ type NullableEach<T> = {
     [P in keyof T]: T[P] | null;
 };
 export type JsonExpr<Value> = [NonNullable<Value>] extends [Array<infer V>] ? JsonArrayHasSql<null extends Value ? V | null : V> : [NonNullable<Value>] extends [object] ? JsonRecordHasSql<null extends Value ? NullableEach<Value> : Value> : HasSql<Value>;
+export interface JsonPath {
+    target: Sql;
+    segments: Array<number | string>;
+    asSql: boolean;
+}
 export declare function jsonExpr<Value>(e: HasSql<Value>): JsonExpr<Value>;
-export declare function jsonAggregateArray(...args: Array<Input<unknown>>): import("../Sql.ts").Sql<unknown>;
-export declare function jsonArray(...args: Array<Input<unknown>>): import("../Sql.ts").Sql<unknown>;
+export declare function jsonAggregateArray(...args: Array<Input<unknown>>): Sql<unknown>;
+export declare function jsonArray(...args: Array<Input<unknown>>): Sql<unknown>;
 export {};

package/dist/core/expr/Json.js

@@ -1,4 +1,5 @@
 // src/core/expr/Json.ts
+import { getSql } from "../Internal.js";
 import { sql } from "../Sql.js";
 import { callFunction } from "./Functions.js";
 var INDEX_PROPERTY = /^\d+$/;
@@ -8,7 +9,17 @@ function jsonExpr(e) {
       if (typeof prop !== "string")
         return Reflect.get(target, prop);
       const isNumber = INDEX_PROPERTY.test(prop);
-      return jsonExpr(sql`${target}`.jsonPath([isNumber ? Number(prop) : prop]));
+      return jsonExpr(
+        sql.jsonPath({
+          target: getSql(target),
+          asSql: true,
+          segments: [isNumber ? Number(prop) : prop]
+        }).mapWith({
+          mapFromDriverValue(value, specs) {
+            return specs.parsesJson ? value : JSON.parse(value);
+          }
+        })
+      );
     }
   });
 }

package/dist/mysql/dialect.js

@@ -16,10 +16,12 @@ var mysqlDialect = new Dialect(
       this.sql += "?";
       this.params.push(new ValueParam(value));
     }
-    emitJsonPath(path) {
-      this.sql += `->>${this.quoteString(
-        `$${path.map((p) => typeof p === "number" ? `[${p}]` : `.${p}`).join("")}`
-      )}`;
+    emitJsonPath({ target, asSql, segments }) {
+      target.emitTo(this);
+      this.sql += asSql ? "->>" : "->";
+      this.sql += this.quoteString(
+        `$${segments.map((p) => typeof p === "number" ? `[${p}]` : `.${p}`).join("")}`
+      );
     }
     emitInline(value) {
       if (value === null || value === void 0)

package/dist/postgres/dialect.js

@@ -16,13 +16,14 @@ var postgresDialect = new Dialect(
       this.sql += `$${++this.paramIndex}`;
       this.params.push(new ValueParam(value));
     }
-    emitJsonPath(path) {
-      for (let i = 0; i < path.length; i++) {
-        const access = path[i];
-        if (i <= path.length - 2)
+    emitJsonPath({ target, asSql, segments }) {
+      target.emitTo(this);
+      for (let i = 0; i < segments.length; i++) {
+        const access = segments[i];
+        if (i <= segments.length - 2)
           this.sql += "->";
-        else if (i === path.length - 1)
-          this.sql += "->>";
+        else if (i === segments.length - 1)
+          this.sql += asSql ? "->>" : "->";
         if (typeof access === "number")
           this.sql += access;
         else

package/dist/sqlite/dialect.js

@@ -18,10 +18,12 @@ var sqliteDialect = new Dialect(
       this.sql += "?";
       this.params.push(new ValueParam(value));
     }
-    emitJsonPath(path) {
-      this.sql += `->>${this.quoteString(
-        `$${path.map((p) => typeof p === "number" ? `[${p}]` : `.${p}`).join("")}`
-      )}`;
+    emitJsonPath({ target, asSql, segments }) {
+      target.emitTo(this);
+      this.sql += asSql ? "->>" : "->";
+      this.sql += this.quoteString(
+        `$${segments.map((p) => typeof p === "number" ? `[${p}]` : `.${p}`).join("")}`
+      );
     }
     emitInline(value) {
       if (value === null || value === void 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -27,7 +27,7 @@
   "files": ["dist"],
   "devDependencies": {
     "@benmerckx/suite": "^0.3.0",
-    "@biomejs/biome": "^1.6.1",
+    "@biomejs/biome": "^1.8.3",
     "@cloudflare/workers-types": "^4.20230628.0",
     "@electric-sql/pglite": "^0.1.5",
     "@sqlite.org/sqlite-wasm": "^3.42.0-build4",