feat(builder, utils): rename precompile methods

Author: subframe7536

packages/sqlite-builder/src/builder.ts

@@ -269,15 +269,15 @@ export class SqliteBuilder<DB extends Record<string, any>> {
        * @param queryBuilder param builder
        * @returns function to {@link CompileFn compile}
        */
-      query: <O>(
+      build: <O>(
         queryBuilder: (db: Kysely<DB>, param: <K extends keyof T>(name: K) => T[K]) => Compilable<O>,
       ) => {
         let compiled: CompiledQuery<Compilable<O>> | null
         const dispose = () => compiled = null
         return {
           [Symbol.dispose]: dispose,
           dispose,
-          generate: (param: T) => {
+          compile: (param: T) => {
             if (!compiled) {
               const { parameters, sql, query } = queryBuilder(this.kysely, getPrecompileParam).compile()
               compiled = {

packages/sqlite-utils/README.md

@@ -37,10 +37,10 @@ function createPrecompile<T extends Record<string, any>>(options?: PrecompileOpt
    * @param queryBuilder param builder
    * @returns function to {@link CompileFn compile}
    */
-  query: <O>(queryBuilder: (param: <K extends keyof T>(name: K) => T[K]) => Compilable<O>) => {
+  build: <O>(queryBuilder: (param: <K extends keyof T>(name: K) => T[K]) => Compilable<O>) => {
     [Symbol.dispose]: () => null
     dispose: () => null
-    generate: (param: T) => CompiledQuery<QueryBuilderOutput<O>>
+    compile: (param: T) => CompiledQuery<QueryBuilderOutput<O>>
   }
 }
 // old util, reference from https://github.com/jtlapp/kysely-params

packages/sqlite-utils/src/precompile.ts

@@ -100,7 +100,7 @@ export function precompileQuery<O>(
  *   .query((param) =>
  *     db.selectFrom('test').selectAll().where('name', '=', param('name')),
  *   )
- * const compileResult = select.generate({ name: 'test' })
+ * const compileResult = select.compile({ name: 'test' })
  * // {
  * //   sql: 'select * from "test" where "name" = ?',
  * //   parameters: ['test'],
@@ -110,7 +110,7 @@ export function precompileQuery<O>(
  *
  * // or auto disposed by using
  * using selectWithUsing = createPrecompile<{ name: string }>(options)
- *   .query((param) =>
+ *   .build((param) =>
  *     db.selectFrom('test').selectAll().where('name', '=', param('name')),
  *   )
  */
@@ -125,15 +125,15 @@ export function createPrecompile<T extends Record<string, any>>(options: Precomp
      * @param queryBuilder param builder
      * @returns function to {@link CompileFn compile}
      */
-    query: <O>(
+    build: <O>(
       queryBuilder: (param: <K extends keyof T>(name: K) => T[K]) => Compilable<O>,
     ) => {
       let compiled: CompiledQuery<Compilable<O>> | null
       const dispose = () => compiled = null
       return {
         [Symbol.dispose]: dispose,
         dispose,
-        generate: (param: T) => {
+        compile: (param: T) => {
           if (!compiled) {
             const { parameters, sql, query } = queryBuilder(getPrecompileParam).compile()
             compiled = {

test/builder.test.ts

@@ -126,36 +126,36 @@ describe('test builder', async () => {
   })
   it('should precompile', async () => {
     const select = db.precompile<{ person: { name: string }, test?: 'asd' }>()
-      .query((d, param) =>
+      .build((d, param) =>
         d.selectFrom('test').selectAll().where('person', '=', param('person')),
       )
     const insert = db.precompile<{ gender: boolean }>()
-      .query((db, param) =>
+      .build((db, param) =>
         db.insertInto('test').values({ gender: param('gender') }),
       )
     const update = db.precompile<{ gender: boolean }>()
-      .query((db, param) =>
+      .build((db, param) =>
         db.updateTable('test').set({ gender: param('gender') }).where('id', '=', 1),
       )
 
     const start = performance.now()
 
-    const { parameters, sql } = select.generate({ person: { name: '1' } })
+    const { parameters, sql } = select.compile({ person: { name: '1' } })
     expect(sql).toBe('select * from "test" where "person" = ?')
     expect(parameters).toStrictEqual(['{"name":"1"}'])
 
     const start2 = performance.now()
     console.log('no compiled:', `${(start2 - start).toFixed(2)}ms`)
 
-    const { parameters: p1, sql: s1 } = select.generate({ person: { name: 'test' } })
+    const { parameters: p1, sql: s1 } = select.compile({ person: { name: 'test' } })
     expect(s1).toBe('select * from "test" where "person" = ?')
     expect(p1).toStrictEqual(['{"name":"test"}'])
 
     console.log('   compiled:', `${(performance.now() - start2).toFixed(2)}ms`)
 
-    const result = await db.execute(insert.generate({ gender: true }))
+    const result = await db.execute(insert.compile({ gender: true }))
     expect(result.rows).toStrictEqual([])
-    const result2 = await db.execute(update.generate({ gender: false }))
+    const result2 = await db.execute(update.compile({ gender: false }))
     expect(result2.rows).toStrictEqual([])
   })
 })