Add it.Apply (#64)

Author: lucasavila00

docs-eval/apply.md

@@ -0,0 +1,40 @@
+---
+title: Apply
+nav_order: 90
+parent: Examples
+layout: default
+---
+
+<details open markdown="block">
+  <summary>
+    Table of contents
+  </summary>
+  {: .text-delta }
+1. TOC
+{:toc}
+</details>
+
+```ts eval --replacePrintedInput=../src,sql-select-ts
+import { table, dsql as sql, select } from "../src";
+import { SelectStatement } from "../src/classes/select-statement";
+```
+
+# Apply
+
+Allows to use a helper function but still keep method chaining.
+
+```ts eval --yield=sql
+// It expects a select statement that has selected a "sector" field,
+// which will be used as the "group by"
+const groupSortLimit = (query: SelectStatement<never, "sector">) =>
+    query
+        .groupBy((f) => f.sector)
+        .orderBy((_f) => sql`count() DESC`)
+        .limit(250);
+
+const sector_stats = table(["id", "sector", "price"], "sector_stats");
+
+yield select(/* fields: */ ["sector"], /* from: */ sector_stats)
+    .apply(groupSortLimit)
+    .stringify();
+```

docs/api/classes/compound.ts.md

@@ -337,3 +337,15 @@ stringify: () => string;
 ```
 
 Added in v0.0.0
+
+### apply (property)
+
+**Signature**
+
+```ts
+apply: <Ret extends TableOrSubquery<any, any, any, any> = never>(
+  fn: (it: this) => Ret
+) => Ret;
+```
+
+Added in v1.1.1

docs/api/classes/joined.ts.md

@@ -289,6 +289,18 @@ joinCompound: <
 
 Added in v0.0.0
 
+### apply (property)
+
+**Signature**
+
+```ts
+apply: <Ret extends TableOrSubquery<any, any, any, any> = never>(
+  fn: (it: this) => Ret
+) => Ret;
+```
+
+Added in v1.1.1
+
 ## JoinedFactory (class)
 
 Constructor for join queries.

docs/api/classes/select-statement.ts.md

@@ -91,7 +91,7 @@ select: <
   f:
     | readonly SubSelection[]
     | ((
-        f: Record<Selection | Scope, SafeString> & NoSelectFieldsCompileError
+        f: Record<Selection, SafeString> & NoSelectFieldsCompileError
       ) => Record<NewSelection, SafeString>)
 ) => SelectStatement<Selection, NewSelection | SubSelection>;
 ```
@@ -441,6 +441,18 @@ joinCompound: <
 
 Added in v0.0.0
 
+### apply (property)
+
+**Signature**
+
+```ts
+apply: <Ret extends TableOrSubquery<any, any, any, any> = never>(
+  fn: (it: this) => Ret
+) => Ret;
+```
+
+Added in v1.1.1
+
 ### stringify (property)
 
 **Signature**

docs/api/classes/stringified-select-statement.ts.md

@@ -294,6 +294,18 @@ joinCompound: <
 
 Added in v0.0.3
 
+### apply (property)
+
+**Signature**
+
+```ts
+apply: <Ret extends TableOrSubquery<any, any, any, any> = never>(
+  fn: (it: this) => Ret
+) => Ret;
+```
+
+Added in v1.1.1
+
 ### stringify (property)
 
 **Signature**

docs/api/classes/table.ts.md

@@ -287,3 +287,15 @@ joinCompound: <Selection2 extends string, Alias2 extends string>(
 ```
 
 Added in v0.0.0
+
+### apply (property)
+
+**Signature**
+
+```ts
+apply: <Ret extends TableOrSubquery<any, any, any, any> = never>(
+  fn: (it: this) => Ret
+) => Ret;
+```
+
+Added in v1.1.1

docs/examples/apply.md

@@ -0,0 +1,53 @@
+---
+title: Apply
+nav_order: 90
+parent: Examples
+layout: default
+---
+
+<details open markdown="block">
+  <summary>
+    Table of contents
+  </summary>
+  {: .text-delta }
+1. TOC
+{:toc}
+</details>
+
+```ts
+import { table, dsql as sql, select } from "sql-select-ts";
+import { SelectStatement } from "sql-select-ts/classes/select-statement";
+```
+
+# Apply
+
+Allows to use a helper function but still keep method chaining.
+
+```ts
+// It expects a select statement that has selected a "sector" field,
+// which will be used as the "group by"
+const groupSortLimit = (query: SelectStatement<never, "sector">) =>
+  query
+    .groupBy((f) => f.sector)
+    .orderBy((_f) => sql`count() DESC`)
+    .limit(250);
+
+const sector_stats = table(["id", "sector", "price"], "sector_stats");
+
+select(/* fields: */ ["sector"], /* from: */ sector_stats)
+  .apply(groupSortLimit)
+  .stringify();
+```
+
+```sql
+SELECT
+  `sector` AS `sector`
+FROM
+  `sector_stats`
+GROUP BY
+  `sector`
+ORDER BY
+  count() DESC
+LIMIT
+  250
+```

src/classes/compound.ts

@@ -453,4 +453,11 @@ export class Compound<Scope extends string, Selection extends string> {
      * @since 0.0.0
      */
     public stringify = (): string => printCompound(this);
+
+    /**
+     * @since 1.1.1
+     */
+    public apply = <Ret extends TableOrSubquery<any, any, any, any> = never>(
+        fn: (it: this) => Ret
+    ): Ret => fn(this);
 }

src/classes/joined.ts

@@ -417,4 +417,11 @@ export class Joined<
                 operator,
             }
         );
+
+    /**
+     * @since 1.1.1
+     */
+    public apply = <Ret extends TableOrSubquery<any, any, any, any> = never>(
+        fn: (it: this) => Ret
+    ): Ret => fn(this);
 }

src/classes/select-statement.ts

@@ -256,8 +256,7 @@ export class SelectStatement<Scope extends string, Selection extends string> {
         f:
             | ReadonlyArray<SubSelection>
             | ((
-                  f: Record<Selection | Scope, SafeString> &
-                      NoSelectFieldsCompileError
+                  f: Record<Selection, SafeString> & NoSelectFieldsCompileError
               ) => Record<NewSelection, SafeString>)
     ): SelectStatement<Selection, NewSelection | SubSelection> =>
         SelectStatement.__fromTableOrSubquery(this, [
@@ -636,6 +635,13 @@ export class SelectStatement<Scope extends string, Selection extends string> {
             }
         );
 
+    /**
+     * @since 1.1.1
+     */
+    public apply = <Ret extends TableOrSubquery<any, any, any, any> = never>(
+        fn: (it: this) => Ret
+    ): Ret => fn(this);
+
     /**
      * @since 0.0.0
      */

src/classes/stringified-select-statement.ts

@@ -5,7 +5,7 @@
  * @since 0.0.3
  */
 import { SafeString } from "../safe-string";
-import { NoSelectFieldsCompileError } from "../types";
+import { NoSelectFieldsCompileError, TableOrSubquery } from "../types";
 import { Compound } from "./compound";
 import { Joined, JoinedFactory } from "./joined";
 import { SelectStatement } from "./select-statement";
@@ -332,6 +332,13 @@ export class StringifiedSelectStatement<Selection extends string> {
             }
         );
 
+    /**
+     * @since 1.1.1
+     */
+    public apply = <Ret extends TableOrSubquery<any, any, any, any> = never>(
+        fn: (it: this) => Ret
+    ): Ret => fn(this);
+
     /**
      * @since 0.0.3
      */

src/classes/table.ts

@@ -9,7 +9,7 @@
 import { consumeRecordCallback } from "../consume-fields";
 import { AliasedRows, StarSymbol } from "../data-wrappers";
 import { SafeString } from "../safe-string";
-import { NoSelectFieldsCompileError } from "../types";
+import { NoSelectFieldsCompileError, TableOrSubquery } from "../types";
 import { Compound } from "./compound";
 import { Joined, JoinedFactory } from "./joined";
 import { SelectStatement } from "./select-statement";
@@ -338,4 +338,11 @@ export class Table<Selection extends string, Alias extends string> {
                 operator,
             }
         );
+
+    /**
+     * @since 1.1.1
+     */
+    public apply = <Ret extends TableOrSubquery<any, any, any, any> = never>(
+        fn: (it: this) => Ret
+    ): Ret => fn(this);
 }

tests/sqlite-suite/select1.test.ts

@@ -46,6 +46,28 @@ describe("sqlite select1", () => {
         await run(`INSERT INTO t6 VALUES('c','2');`);
         await run(`INSERT INTO t6 VALUES('d','3');`);
     });
+
+    it("apply type checks", async () => {
+        const q1 = test1.selectStar();
+        unionAll([q1, q1, q1])
+            .apply((it) => it.select(["f1"]))
+            .select((f) => ({
+                //@ts-expect-error
+                b: f.f2,
+            }))
+            .stringify();
+        expect(1).toBe(1);
+
+        unionAll([q1, q1, q1])
+            .select(["f1"])
+            .select((f) => ({
+                //@ts-expect-error
+                b: f.f2,
+            }))
+            .stringify();
+        expect(1).toBe(1);
+    });
+
     it("select0", async () => {
         const q = test1
             .select((f) => ({
@@ -1264,6 +1286,7 @@ describe("sqlite select1", () => {
             .select((f) => ({
                 a: f.f1,
                 b: f.f2,
+                //@ts-expect-error
                 c: f["it.r1"],
             }))
             .stringify();

tests/unit/union.test.ts renamed to tests/unit/compound.test.ts

@@ -1,7 +1,7 @@
 import { table, unionAll } from "../../src";
 import * as NEA from "fp-ts/lib/NonEmptyArray";
 const cols = ["a", "b"] as const;
-describe("table", () => {
+describe("compound unit", () => {
     it("works", () => {
         const q1 = table(cols, "a").selectStar();
         const q2 = table(cols, "b").selectStar();
@@ -30,4 +30,24 @@ describe("table", () => {
             `"SELECT * FROM \`a\` UNION ALL SELECT * FROM \`a\` UNION ALL SELECT * FROM \`a\`"`
         );
     });
+
+    it("apply", () => {
+        const q1 = table(cols, "a").selectStar();
+        const u = unionAll([q1, q1, q1]).apply((it) => it.select(["a"]));
+        expect(u.stringify()).toMatchInlineSnapshot(
+            `"SELECT \`a\` AS \`a\` FROM (SELECT * FROM \`a\` UNION ALL SELECT * FROM \`a\` UNION ALL SELECT * FROM \`a\`)"`
+        );
+    });
+
+    it("apply type checks", () => {
+        const q1 = table(cols, "a").selectStar();
+        unionAll([q1, q1, q1])
+            .apply((it) => it.select(["a"]))
+            .select((f) => ({
+                b:
+                    // @ts-expect-error
+                    f.b,
+            }));
+        expect(1).toBe(1);
+    });
 });

tests/unit/join.test.ts

@@ -1,8 +1,8 @@
 import { dsql, table } from "../../src";
 
+const cols = ["a", "b"] as const;
 describe("table", () => {
     it("columns readonly", () => {
-        const cols = ["a", "b"] as const;
         const q = table(cols, "t").select((_f) => ({ a: dsql(1) }));
 
         q.joinSelect("m", "LEFT", "q2", q).on((f) => [
@@ -23,4 +23,26 @@ describe("table", () => {
 
         expect(1).toBe(1);
     });
+
+    it("apply", () => {
+        const t = table(cols, "a");
+        const q = t
+            .commaJoinSelect("a2", t.selectStar())
+            .apply((it) => it.select(["a"]));
+        expect(q.stringify()).toMatchInlineSnapshot(
+            `"SELECT \`a\` AS \`a\` FROM \`a\`, (SELECT * FROM \`a\`) AS \`a2\`"`
+        );
+    });
+
+    it("apply type checks", () => {
+        table(cols, "a")
+            .apply((it) => it.select(["a"]))
+            .select((f) => ({
+                b:
+                    //@ts-expect-error
+                    f.b,
+            }));
+
+        expect(1).toBe(1);
+    });
 });