feat: add Model::params::<field>::as(<alias>) support

src/model.ts

@@ -127,9 +127,15 @@ abstract class ModelBase implements ModelInstance {
     }
   }
 
-  protected build_param_sql(schema_field: BuiltSchemaField<string, any>): string {
-    return `:${schema_field.field_name}`
+  protected build_param_sql(schema_field: ParamsField<any>): string {
+    if (schema_field.alias_of) {
+      console.debug(schema_field.alias_of)
+      return `:${schema_field.field_name}`
+    } else {
+      return `:${schema_field.field_name}`
+    }
   }
+
   protected build_result_sql(schema_field: ResultField<any>): string {
     const table_name = schema_field.table_name ? `${schema_field.table_name}.` : ''
     if (schema_field.alias_of) {

src/query.ts

@@ -33,7 +33,7 @@ export class Field<T extends SchemaField> implements SchemaField {
   field_name: T['field_name']
   data_transformers: T['data_transformers']
 
-  public constructor(public schema_field: T) {
+  public constructor(public schema_field: T, public alias_of?: string) {
     this.table_name = schema_field.table_name
     this.field_name = schema_field.field_name
     this.data_transformers = schema_field.data_transformers
@@ -44,17 +44,20 @@ export class Field<T extends SchemaField> implements SchemaField {
 // so it cant tell the difference between ParamsField and ResultField if there are no different properties
 export class ParamsField<T extends SchemaField> extends Field<T> {
   type = 'params' as const
+
+
+  public as<A extends string>(alias: A): AliasParamsField<T, A> {
+    return new ParamsField({
+      table_name: this.table_name,
+      field_name: alias,
+      data_transformers: this.data_transformers,
+    }, this.field_name)
+  }
 }
 
 export class ResultField<T extends SchemaField> extends Field<T> {
   type = 'result' as const
 
-  alias_of: string | undefined
-
-  public constructor(schema_field: T, alias_of?: string) {
-    super(schema_field)
-    this.alias_of = alias_of
-  }
 
   public as<A extends string>(alias: A): AliasResultField<T, A> {
     return new ResultField({

test/alias.test.ts

@@ -20,6 +20,10 @@ class Tag extends Model('tag', {
     INNER JOIN tag_group ON tag_group_id = tag_group.id
     WHERE tag.name LIKE ${Tag.params.name} || '%'`.all
 
+  select_by__name__group = this.query`SELECT ${Tag.result['*']} FROM tag
+    INNER JOIN tag_group ON tag_group_id = tag_group.id
+    WHERE tag.name = ${Tag.params.name} AND tag_group.name = ${TagGroup.params.name.as('group')}`
+
   expose_prepare = this.prepare
 }
 
@@ -71,6 +75,13 @@ test('field alias names', async (ctx) => {
   expect_type<{ id: number; name: string; tag_group_id: number } | undefined>(hardcoded_query)
   assert_equals(hardcoded_query, { id: picasso_tag_id, name: 'picasso', tag_group_id: artist_tag_group_id })
 
+  // test params aliases
+  assert_equals({
+    id: 1,
+    tag_group_id: 1,
+    name: 'picasso',
+  }, db.tag.select_by__name__group.one({group: 'artist', name: 'picasso'}))
+
   db.close()
 })