pqb 0.0.1

package/src/queryMethods/json.test.ts

@@ -0,0 +1,398 @@
+import {
+  AssertEqual,
+  expectQueryNotMutated,
+  expectSql,
+  User,
+  userData,
+  useTestDatabase,
+} from '../test-utils';
+import { columnTypes } from '../columnSchema';
+
+describe('json methods', () => {
+  useTestDatabase();
+
+  describe('json', () => {
+    it('wraps a query with json functions', () => {
+      const q = User.all();
+      expectSql(
+        q.where({ id: 1 }).json().toSql(),
+        `
+          SELECT COALESCE(json_agg(row_to_json("t".*)), '[]')
+          FROM (
+            SELECT * FROM "user"
+            WHERE "user"."id" = $1
+          ) AS "t"
+        `,
+        [1],
+      );
+      expectQueryNotMutated(q);
+    });
+
+    it('supports `take`', () => {
+      const q = User.all();
+      expectSql(
+        q.where({ id: 1 }).take().json().toSql(),
+        `
+          SELECT row_to_json("t".*)
+          FROM (
+            SELECT * FROM "user"
+            WHERE "user"."id" = $1
+            LIMIT $2
+          ) AS "t"
+        `,
+        [1, 1],
+      );
+      expectQueryNotMutated(q);
+    });
+  });
+
+  describe('processing and selecting json data', () => {
+    beforeEach(async () => {
+      await User.insert({
+        ...userData,
+        data: { name: 'value', tags: ['one'] },
+      });
+    });
+
+    describe('jsonSet', () => {
+      it('should select json with updated property', async () => {
+        const q = User.all();
+
+        const query = q.jsonSet('data', ['name'], 'new value');
+        expectSql(
+          query.toSql(),
+          `
+            SELECT jsonb_set("user"."data", '{name}', $1) AS "data"
+            FROM "user"
+          `,
+          ['"new value"'],
+        );
+
+        const result = await query.take();
+        expect(result.data).toEqual({ name: 'new value', tags: ['one'] });
+
+        const eq: AssertEqual<
+          typeof result.data,
+          { name: string; tags: string[] } | null
+        > = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+
+      it('should accept optional `as`, `createIfMissing`', async () => {
+        const q = User.all();
+
+        const query = q.jsonSet('data', ['name'], 'new value', {
+          as: 'alias',
+          createIfMissing: true,
+        });
+        expectSql(
+          query.toSql(),
+          `
+            SELECT jsonb_set("user"."data", '{name}', $1, true) AS "alias"
+            FROM "user"
+          `,
+          ['"new value"'],
+        );
+
+        const result = await query.take();
+        expect(result.alias).toEqual({ name: 'new value', tags: ['one'] });
+
+        const eq: AssertEqual<
+          typeof result.alias,
+          { name: string; tags: string[] } | null
+        > = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+
+      it('supports nesting', async () => {
+        const q = User.all();
+
+        const query = q.jsonSet(
+          q.jsonInsert('data', ['tags', 0], 'two'),
+          ['name'],
+          'new value',
+        );
+        expectSql(
+          query.toSql(),
+          `
+            SELECT jsonb_set(
+              jsonb_insert("user"."data", '{tags, 0}', $1),
+              '{name}', $2
+            ) AS "data"
+            FROM "user"
+          `,
+          ['"two"', '"new value"'],
+        );
+
+        const result = await query.take();
+        expect(result.data).toEqual({
+          name: 'new value',
+          tags: ['two', 'one'],
+        });
+
+        const eq: AssertEqual<
+          typeof result.data,
+          { name: string; tags: string[] } | null
+        > = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+    });
+
+    describe('jsonInsert', () => {
+      it('should select json with updated property', async () => {
+        const q = User.all();
+
+        const query = q.jsonInsert('data', ['tags', 0], 'two');
+        expectSql(
+          query.toSql(),
+          `
+            SELECT jsonb_insert("user"."data", '{tags, 0}', $1) AS "data"
+            FROM "user"
+          `,
+          ['"two"'],
+        );
+
+        const result = await query.take();
+        expect(result.data).toEqual({ name: 'value', tags: ['two', 'one'] });
+
+        const eq: AssertEqual<
+          typeof result.data,
+          { name: string; tags: string[] } | null
+        > = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+
+      it('should accept optional `as`, `insertAfter`', async () => {
+        const q = User.all();
+
+        const query = q.jsonInsert('data', ['tags', 0], 'two', {
+          as: 'alias',
+          insertAfter: true,
+        });
+        expectSql(
+          query.toSql(),
+          `
+            SELECT jsonb_insert("user"."data", '{tags, 0}', $1, true) AS "alias"
+            FROM "user"
+          `,
+          ['"two"'],
+        );
+
+        const result = await query.take();
+        expect(result.alias).toEqual({ name: 'value', tags: ['one', 'two'] });
+
+        const eq: AssertEqual<
+          typeof result.alias,
+          { name: string; tags: string[] } | null
+        > = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+
+      it('supports nesting', async () => {
+        const q = User.all();
+
+        const query = q.jsonInsert(
+          q.jsonSet('data', ['tags'], []),
+          ['tags', 0],
+          'tag',
+        );
+        expectSql(
+          query.toSql(),
+          `
+            SELECT jsonb_insert(
+              jsonb_set("user"."data", '{tags}', $1),
+              '{tags, 0}', $2
+            ) AS "data"
+            FROM "user"
+          `,
+          ['[]', '"tag"'],
+        );
+
+        const result = await query.take();
+        expect(result.data).toEqual({ name: 'value', tags: ['tag'] });
+
+        const eq: AssertEqual<
+          typeof result.data,
+          { name: string; tags: string[] } | null
+        > = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+    });
+
+    describe('jsonRemove', () => {
+      it('should select json with removed property', async () => {
+        const q = User.all();
+
+        const query = q.jsonRemove('data', ['tags', 0]);
+        expectSql(
+          query.toSql(),
+          `
+            SELECT "user"."data" #- '{tags, 0}' AS "data"
+            FROM "user"
+          `,
+        );
+
+        const result = await query.take();
+        expect(result.data).toEqual({ name: 'value', tags: [] });
+
+        const eq: AssertEqual<
+          typeof result.data,
+          { name: string; tags: string[] } | null
+        > = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+
+      it('should accept optional `as`', async () => {
+        const q = User.all();
+
+        const query = q.jsonRemove('data', ['tags', 0], { as: 'alias' });
+        expectSql(
+          query.toSql(),
+          `
+            SELECT "user"."data" #- '{tags, 0}' AS "alias"
+            FROM "user"
+          `,
+        );
+
+        const result = await query.take();
+        expect(result.alias).toEqual({ name: 'value', tags: [] });
+
+        const eq: AssertEqual<
+          typeof result.alias,
+          { name: string; tags: string[] } | null
+        > = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+
+      it('supports nesting', async () => {
+        const q = User.all();
+
+        const query = q.jsonRemove(q.jsonSet('data', ['tags'], ['tag']), [
+          'tags',
+          0,
+        ]);
+        expectSql(
+          query.toSql(),
+          `
+            SELECT 
+              jsonb_set("user"."data", '{tags}', $1) #- '{tags, 0}' AS "data"
+            FROM "user"
+          `,
+          ['["tag"]'],
+        );
+
+        const result = await query.take();
+        expect(result.data).toEqual({ name: 'value', tags: [] });
+
+        const eq: AssertEqual<
+          typeof result.data,
+          { name: string; tags: string[] } | null
+        > = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+    });
+
+    describe('jsonPathQuery', () => {
+      it('should select json property', async () => {
+        const q = User.all();
+
+        const query = q.jsonPathQuery(
+          columnTypes.text(),
+          'data',
+          '$.name',
+          'name',
+        );
+        expectSql(
+          query.toSql(),
+          `
+            SELECT jsonb_path_query("user"."data", $1) AS "name"
+            FROM "user"
+          `,
+          ['$.name'],
+        );
+
+        const result = await query.take();
+        expect(result.name).toBe('value');
+
+        const eq: AssertEqual<typeof result.name, string> = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+
+      it('optionally supports vars and silent options', () => {
+        const q = User.all();
+
+        const query = q.jsonPathQuery(
+          columnTypes.text(),
+          'data',
+          '$.name',
+          'name',
+          {
+            vars: 'vars',
+            silent: true,
+          },
+        );
+        expectSql(
+          query.toSql(),
+          `
+            SELECT jsonb_path_query("user"."data", $1, $2, true) AS "name"
+            FROM "user"
+          `,
+          ['$.name', 'vars'],
+        );
+
+        expectQueryNotMutated(q);
+      });
+
+      it('supports nesting', async () => {
+        const q = User.all();
+
+        const query = q.jsonPathQuery(
+          columnTypes.array(columnTypes.text()),
+          q.jsonSet('data', ['tags'], ['tag']),
+          '$.tags',
+          'tags',
+        );
+        expectSql(
+          query.toSql(),
+          `
+            SELECT 
+              jsonb_path_query(
+                jsonb_set("user"."data", '{tags}', $1),
+                $2
+              ) AS "tags"
+            FROM "user"
+          `,
+          ['["tag"]', '$.tags'],
+        );
+
+        const result = await query.take();
+        expect(result.tags).toEqual(['tag']);
+
+        const eq: AssertEqual<typeof result.tags, string[]> = true;
+        expect(eq).toBe(true);
+
+        expectQueryNotMutated(q);
+      });
+    });
+  });
+});

package/src/queryMethods/json.ts

@@ -0,0 +1,259 @@
+import { AddQuerySelect, Query, SetQueryReturnsValueOptional } from '../query';
+import { pushQueryValue } from '../queryDataUtils';
+import { ColumnType, StringColumn } from '../columnSchema';
+import { JsonItem } from '../sql';
+import { raw, StringKey } from '../common';
+
+type JsonColumnName<T extends Pick<Query, 'selectable'>> = StringKey<
+  {
+    [K in keyof T['selectable']]: T['selectable'][K]['column']['dataType'] extends 'jsonb'
+      ? K
+      : never;
+  }[keyof T['selectable']]
+>;
+
+type ColumnOrJsonMethod<T extends Query> = JsonColumnName<T> | JsonItem;
+
+type JsonSetResult<
+  T extends Query,
+  Column extends ColumnOrJsonMethod<T>,
+  As extends string,
+  Type extends ColumnType = Column extends keyof T['shape']
+    ? T['shape'][Column]
+    : Column extends JsonItem
+    ? Column['__json'][2]
+    : ColumnType,
+> = JsonItem<As, Type> &
+  (Type extends ColumnType ? AddQuerySelect<T, Record<As, Type>> : T);
+
+type JsonPathQueryResult<
+  T extends Query,
+  As extends string,
+  Type extends ColumnType,
+> = JsonItem &
+  AddQuerySelect<
+    T,
+    {
+      [K in As]: Type;
+    }
+  >;
+
+export class Json {
+  json<T extends Query>(
+    this: T,
+  ): SetQueryReturnsValueOptional<T, StringColumn> {
+    return this.clone()._json();
+  }
+
+  _json<T extends Query>(
+    this: T,
+  ): SetQueryReturnsValueOptional<T, StringColumn> {
+    const q = this._wrap(this.__model.clone()) as T;
+    q._getOptional(
+      raw<StringColumn>(
+        this.query.take
+          ? `row_to_json("t".*)`
+          : `COALESCE(json_agg(row_to_json("t".*)), '[]')`,
+      ),
+    );
+    delete q.query.take;
+    return q as unknown as SetQueryReturnsValueOptional<T, StringColumn>;
+  }
+
+  jsonSet<
+    T extends Query,
+    Column extends ColumnOrJsonMethod<T>,
+    As extends string = Column extends JsonItem ? Column['__json'][1] : Column,
+  >(
+    this: T,
+    column: Column,
+    path: Array<string | number>,
+    value: unknown,
+    options?: {
+      as?: As;
+      createIfMissing?: boolean;
+    },
+  ): JsonSetResult<T, Column, As> {
+    const q = this.clone() as T;
+    return q._jsonSet(column, path, value, options);
+  }
+
+  _jsonSet<
+    T extends Query,
+    Column extends ColumnOrJsonMethod<T>,
+    As extends string = Column extends JsonItem ? Column['__json'][1] : Column,
+  >(
+    this: T,
+    column: Column,
+    path: Array<string | number>,
+    value: unknown,
+    options?: {
+      as?: As;
+      createIfMissing?: boolean;
+    },
+  ): JsonSetResult<T, Column, As> {
+    const json: JsonItem = {
+      __json: [
+        'set',
+        options?.as ??
+          (typeof column === 'string'
+            ? column
+            : (column as JsonItem).__json[1]),
+        typeof column === 'string'
+          ? this.shape[column]
+          : (column as JsonItem).__json[2],
+        column,
+        path,
+        value,
+        options,
+      ],
+    };
+
+    return Object.assign(
+      pushQueryValue(this, 'select', json),
+      json,
+    ) as unknown as JsonSetResult<T, Column, As>;
+  }
+
+  jsonInsert<
+    T extends Query,
+    Column extends ColumnOrJsonMethod<T>,
+    As extends string = Column extends JsonItem ? Column['__json'][1] : Column,
+  >(
+    this: T,
+    ...args: [
+      column: Column,
+      path: Array<string | number>,
+      value: unknown,
+      options?: {
+        as?: As;
+        insertAfter?: boolean;
+      },
+    ]
+  ): JsonSetResult<T, Column, As> {
+    const q = this.clone() as T;
+    return q._jsonInsert(...args);
+  }
+
+  _jsonInsert<
+    T extends Query,
+    Column extends ColumnOrJsonMethod<T>,
+    As extends string = Column extends JsonItem ? Column['__json'][1] : Column,
+  >(
+    this: T,
+    column: Column,
+    path: Array<string | number>,
+    value: unknown,
+    options?: {
+      as?: As;
+      insertAfter?: boolean;
+    },
+  ): JsonSetResult<T, Column, As> {
+    const json: JsonItem = {
+      __json: [
+        'insert',
+        options?.as ??
+          (typeof column === 'string'
+            ? column
+            : (column as JsonItem).__json[1]),
+        typeof column === 'string'
+          ? this.shape[column]
+          : (column as JsonItem).__json[2],
+        column,
+        path,
+        value,
+        options,
+      ],
+    };
+
+    return Object.assign(
+      pushQueryValue(this, 'select', json),
+      json,
+    ) as unknown as JsonSetResult<T, Column, As>;
+  }
+
+  jsonRemove<
+    T extends Query,
+    Column extends ColumnOrJsonMethod<T>,
+    As extends string = Column extends JsonItem ? Column['__json'][1] : Column,
+  >(
+    this: T,
+    ...args: [
+      column: Column,
+      path: Array<string | number>,
+      options?: { as?: As },
+    ]
+  ): JsonSetResult<T, Column, As> {
+    const q = this.clone() as T;
+    return q._jsonRemove(...args);
+  }
+
+  _jsonRemove<
+    T extends Query,
+    Column extends ColumnOrJsonMethod<T>,
+    As extends string = Column extends JsonItem ? Column['__json'][1] : Column,
+  >(
+    this: T,
+    column: Column,
+    path: Array<string | number>,
+    options?: { as?: As },
+  ): JsonSetResult<T, Column, As> {
+    const json: JsonItem = {
+      __json: [
+        'remove',
+        options?.as ??
+          (typeof column === 'string'
+            ? column
+            : (column as JsonItem).__json[1]),
+        typeof column === 'string'
+          ? this.shape[column]
+          : (column as JsonItem).__json[2],
+        column,
+        path,
+      ],
+    };
+
+    return Object.assign(
+      pushQueryValue(this, 'select', json),
+      json,
+    ) as unknown as JsonSetResult<T, Column, As>;
+  }
+
+  jsonPathQuery<T extends Query, As extends string, Type extends ColumnType>(
+    this: T,
+    ...args: [
+      type: Type,
+      column: ColumnOrJsonMethod<T>,
+      path: string,
+      as: As,
+      options?: {
+        vars?: string;
+        silent?: boolean;
+      },
+    ]
+  ): JsonPathQueryResult<T, As, Type> {
+    const q = this.clone() as T;
+    return q._jsonPathQuery(...args);
+  }
+
+  _jsonPathQuery<T extends Query, As extends string, Type extends ColumnType>(
+    this: T,
+    type: Type,
+    column: ColumnOrJsonMethod<T>,
+    path: string,
+    as: As,
+    options?: {
+      vars?: string;
+      silent?: boolean;
+    },
+  ): JsonPathQueryResult<T, As, Type> {
+    const json: JsonItem = {
+      __json: ['pathQuery', as, type, column, path, options],
+    };
+
+    return Object.assign(
+      pushQueryValue(this, 'select', json),
+      json,
+    ) as unknown as JsonPathQueryResult<T, As, Type>;
+  }
+}