@getstrata/core 1.0.5 → 1.0.6

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @getstrata/core changelog
 
+## 1.0.6
+
+- Query `pluck` and `value` on `RepositoryQuery`, `ModelQuery`, and relation queries. `pluck(column)` returns `T[]`; `pluck(column, keyBy)` returns a `Map`. Models apply `$casts` and skip hydration/observers. Generated apps and lockstep packages move to `^1.0.6`.
+
 ## 1.0.5
 
 - `@getstrata/core/database/mysqlConnection` re-exports the barrel so the barrel and the subpath share one lazy `mysql2` load. Importing both in one process no longer starts two independent loaders.

package/dist/core/database/index.d.ts

@@ -14,6 +14,7 @@ export type { MysqlConnection, MysqlExecutable, MysqlPool } from "./mysqlConnect
 export { createMysqlConnection, createMysqlConnectionFromPool, createMysqlPool, } from "./mysqlConnection.ts";
 export type { NamedConnectionEntry } from "./namedConnections.ts";
 export { getNamedConnection, hasNamedConnection, registerNamedConnection, resetNamedConnections, runOnNamedConnection, unregisterNamedConnection, } from "./namedConnections.ts";
+export { projectPluck, uniqueColumnSelect } from "./pluck.ts";
 export { buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, } from "./query.ts";
 export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "./relationships.ts";
 export { belongsTo, belongsToMany, hasMany, hasManyThrough, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasManyThroughRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } from "./relationships.ts";

package/dist/core/database/model.d.ts

@@ -61,6 +61,10 @@ declare class ModelQuery {
     onlyTrashed(): this;
     get(): Promise<Array<Model<Record<string, unknown>, "id">>>;
     first(): Promise<Model<Record<string, unknown>, "id"> | null>;
+    count(): Promise<number>;
+    pluck(column: string): Promise<unknown[]>;
+    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    value(column: string): Promise<unknown>;
     find(id: unknown): Promise<Model<Record<string, unknown>, "id"> | null>;
     findOrFail(id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
     then(onfulfilled?: ((value: Array<Model<Record<string, unknown>, "id">>) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
@@ -129,6 +133,10 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     static findOrFail(this: object, id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
     static all(this: object, options?: Omit<QueryOptions<object>, "where">): Promise<Array<Model<Record<string, unknown>, "id">>>;
     static where(this: object, where: QueryWhere<object>): ModelQuery;
+    static count(this: object): Promise<number>;
+    static pluck(this: object, column: string): Promise<unknown[]>;
+    static pluck(this: object, column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    static value(this: object, column: string): Promise<unknown>;
     static firstWhere(this: object, where: QueryWhere<object>, options?: Omit<QueryOptions<object>, "where">): Promise<Model<Record<string, unknown>, "id"> | null>;
     static firstOrNew(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
     static firstOrCreate(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;

package/dist/core/database/pluck.d.ts

@@ -0,0 +1,5 @@
+import type { QuerySelectItem } from "./types.ts";
+declare function uniqueColumnSelect(table: string, columns: readonly string[]): QuerySelectItem[];
+declare function projectPluck<T extends object, K extends keyof T & string>(rows: readonly T[], column: K): Array<T[K]>;
+declare function projectPluck<T extends object, K extends keyof T & string, KK extends keyof T & string>(rows: readonly T[], column: K, keyBy: KK): Map<T[KK], T[K]>;
+export { projectPluck, uniqueColumnSelect };

package/dist/core/database/relationQuery.d.ts

@@ -40,6 +40,9 @@ declare class HasManyRelationQuery<TParent extends object, ParentKey extends key
     get(): Promise<RelatedRecord[]>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
+    pluck(column: string): Promise<unknown[]>;
+    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    value(column: string): Promise<unknown>;
     then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
     save(related: RelatedRecord | (Record<string, unknown> & {
@@ -61,6 +64,9 @@ declare class HasOneRelationQuery<TParent extends object, ParentKey extends keyo
     get(): Promise<RelatedRecord | null>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
+    pluck(column: string): Promise<unknown[]>;
+    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    value(column: string): Promise<unknown>;
     then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
     save(related: RelatedRecord | Record<string, unknown>): Promise<RelatedRecord>;
@@ -80,6 +86,10 @@ declare class BelongsToRelationQuery<TChild extends object, ChildKey extends key
     toExistsClause(parentTable: string): ExistsClause;
     get(): Promise<RelatedRecord | null>;
     first(): Promise<RelatedRecord | null>;
+    pluck(column: string): Promise<unknown[]>;
+    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    value(column: string): Promise<unknown>;
+    private relatedQuery;
     then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     associate(owner: {
         id?: unknown;
@@ -105,6 +115,10 @@ declare class BelongsToManyRelationQuery<TParent extends object, ParentKey exten
     get(): Promise<RelatedRecord[]>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
+    pluck(column: string): Promise<unknown[]>;
+    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    value(column: string): Promise<unknown>;
+    private relatedQuery;
     then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     attach(ids: unknown | readonly unknown[]): Promise<void>;
     toggle(ids: unknown | readonly unknown[]): Promise<void>;
@@ -124,9 +138,13 @@ declare class MorphManyRelationQuery<TParent extends object, ParentKey extends k
     applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
     hydrateEager(row: Record<string, unknown>, alias: string): unknown;
     toExistsClause(parentTable: string): ExistsClause;
+    private scopedQuery;
     get(): Promise<RelatedRecord[]>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
+    pluck(column: string): Promise<unknown[]>;
+    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    value(column: string): Promise<unknown>;
     then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
 }
@@ -142,6 +160,9 @@ declare class MorphOneRelationQuery<TParent extends object, ParentKey extends ke
     get(): Promise<RelatedRecord | null>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
+    pluck(column: string): Promise<unknown[]>;
+    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    value(column: string): Promise<unknown>;
     then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
 }
@@ -157,6 +178,11 @@ declare class MorphToRelationQuery<TChild extends object, ChildKey extends keyof
     hydrateEager(row: Record<string, unknown>, alias: string): unknown;
     toExistsClause(parentTable: string): ExistsClause;
     get(): Promise<RelatedRecord | null>;
+    pluck(column: string): Promise<unknown[]>;
+    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    value(column: string): Promise<unknown>;
+    private relatedForCurrentType;
+    private relatedQuery;
     then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
 }
 declare class HasManyThroughRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TFar extends object, FarKey extends keyof TFar & string> {
@@ -176,6 +202,10 @@ declare class HasManyThroughRelationQuery<TParent extends object, ParentKey exte
     get(): Promise<RelatedRecord[]>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
+    pluck(column: string): Promise<unknown[]>;
+    pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
+    value(column: string): Promise<unknown>;
+    private farRows;
     then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
 }
 type AnyRelationQuery = {

package/dist/core/database/repositoryQuery.d.ts

@@ -37,6 +37,9 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     get(): Promise<Array<TEntity & LoadedRow>>;
     first(): Promise<(TEntity & LoadedRow) | null>;
     count(): Promise<number>;
+    pluck<K extends keyof TEntity & string>(column: K): Promise<Array<TEntity[K]>>;
+    pluck<K extends keyof TEntity & string, KK extends keyof TEntity & string>(column: K, keyBy: KK): Promise<Map<TEntity[KK], TEntity[K]>>;
+    value<K extends keyof TEntity & string>(column: K): Promise<TEntity[K] | null>;
     attachToRows(rows: readonly TEntity[]): Promise<Array<TEntity & LoadedRow>>;
     paginate(options: {
         page: number;
@@ -47,4 +50,5 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     private attach;
     private hydrateEagerLoad;
 }
+export { projectPluck, uniqueColumnSelect } from "./pluck.ts";
 export { RepositoryQuery };

package/dist/entries/database/model.js

@@ -458,6 +458,30 @@ function buildDeleteByIdQuery(table, id) {
   };
 }
 
+// ../../src/core/database/pluck.ts
+function uniqueColumnSelect(table, columns) {
+  const seen = new Set;
+  const select = [];
+  for (const column of columns) {
+    if (seen.has(column)) {
+      continue;
+    }
+    seen.add(column);
+    select.push({ kind: "column", table, column, as: column });
+  }
+  return select;
+}
+function projectPluck(rows, column, keyBy) {
+  if (keyBy === undefined) {
+    return rows.map((row) => row[column]);
+  }
+  const keyed = new Map;
+  for (const row of rows) {
+    keyed.set(row[keyBy], row[column]);
+  }
+  return keyed;
+}
+
 // ../../src/core/database/relationQuery.ts
 function asWhere(where) {
   return where;
@@ -474,6 +498,12 @@ function ownerId(owner, ownerKey) {
 function thenGet(get, onfulfilled, onrejected) {
   return get().then(onfulfilled ?? undefined, onrejected ?? undefined);
 }
+function pluckFromQuery(query, column, keyBy) {
+  if (!query) {
+    return Promise.resolve(keyBy === undefined ? [] : new Map);
+  }
+  return keyBy === undefined ? query.pluck(column) : query.pluck(column, keyBy);
+}
 
 class HasManyRelationQuery {
   parent;
@@ -539,6 +569,12 @@ class HasManyRelationQuery {
   async count() {
     return this.scopedQuery().count();
   }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(this.scopedQuery(), column, keyBy);
+  }
+  async value(column) {
+    return this.scopedQuery().value(column);
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -604,6 +640,13 @@ class HasOneRelationQuery {
   async count() {
     return this.inner.count();
   }
+  async pluck(column, keyBy) {
+    const query = this.inner.limit(1);
+    return keyBy === undefined ? query.pluck(column) : query.pluck(column, keyBy);
+  }
+  async value(column) {
+    return this.inner.limit(1).value(column);
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -650,6 +693,23 @@ class BelongsToRelationQuery {
     return { sql, params: extra.params };
   }
   async get() {
+    const query = this.relatedQuery();
+    if (!query) {
+      return null;
+    }
+    const row = await query.first();
+    return row ? this.related.newFromRecord(row) : null;
+  }
+  async first() {
+    return this.get();
+  }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(this.relatedQuery(), column, keyBy);
+  }
+  async value(column) {
+    return this.relatedQuery()?.value(column) ?? null;
+  }
+  relatedQuery() {
     const foreign = this.parent.get(this.relation.foreignKey);
     if (foreign === null || foreign === undefined) {
       return null;
@@ -659,11 +719,7 @@ class BelongsToRelationQuery {
     if (this.extraOptions.orderBy) {
       query = query.orderBy(this.extraOptions.orderBy);
     }
-    const row = await query.first();
-    return row ? this.related.newFromRecord(row) : null;
-  }
-  async first() {
-    return this.get();
+    return query;
   }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
@@ -751,6 +807,31 @@ class BelongsToManyRelationQuery {
     const rows = await this.connection().unsafe(`SELECT COUNT(*) AS count FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1`, [parentId]);
     return Number(rows[0]?.count ?? 0);
   }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(await this.relatedQuery(), column, keyBy);
+  }
+  async value(column) {
+    const query = await this.relatedQuery();
+    return query ? query.value(column) : null;
+  }
+  async relatedQuery() {
+    const parentId = this.parent.get(this.relation.parentKey);
+    const pivotRows = await this.connection().unsafe(`SELECT * FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1`, [parentId]);
+    if (pivotRows.length === 0) {
+      return null;
+    }
+    const relatedIds = [
+      ...new Set(pivotRows.map((row) => row[this.relation.relatedPivotKey]))
+    ];
+    let query = this.related.repository().withConnection(this.connection()).query(asWhere({
+      [this.relation.relatedKey]: relatedIds,
+      ...this.extraWhere
+    }));
+    if (this.extraOptions.orderBy) {
+      query = query.orderBy(this.extraOptions.orderBy);
+    }
+    return query;
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -834,13 +915,15 @@ class MorphManyRelationQuery {
     const sql = `SELECT 1 FROM ${quoteIdentifier(childTable)} WHERE ${qualifyColumn(childTable, this.relation.morphIdKey)} = ${qualifyColumn(parentTable, this.relation.localKey)}${extraSql ? ` AND ${extraSql}` : ""}`;
     return { sql, params: extra.params };
   }
-  async get() {
-    const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
-    const rows = await repository.query(asWhere({
+  scopedQuery() {
+    return this.related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({
       [this.relation.morphTypeKey]: this.relation.morphType,
       [this.relation.morphIdKey]: this.parent.get(this.relation.localKey),
       ...this.extraWhere
-    })).get();
+    }));
+  }
+  async get() {
+    const rows = await this.scopedQuery().get();
     return rows.map((row) => this.related.newFromRecord(row));
   }
   async first() {
@@ -848,12 +931,13 @@ class MorphManyRelationQuery {
     return rows[0] ?? null;
   }
   async count() {
-    const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
-    return repository.query(asWhere({
-      [this.relation.morphTypeKey]: this.relation.morphType,
-      [this.relation.morphIdKey]: this.parent.get(this.relation.localKey),
-      ...this.extraWhere
-    })).count();
+    return this.scopedQuery().count();
+  }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(this.scopedQuery(), column, keyBy);
+  }
+  async value(column) {
+    return this.scopedQuery().value(column);
   }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
@@ -904,6 +988,12 @@ class MorphOneRelationQuery {
   async count() {
     return this.inner.count();
   }
+  async pluck(column, keyBy) {
+    return keyBy === undefined ? this.inner.pluck(column) : this.inner.pluck(column, keyBy);
+  }
+  async value(column) {
+    return this.inner.value(column);
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -952,15 +1042,31 @@ class MorphToRelationQuery {
     };
   }
   async get() {
+    const query = this.relatedQuery();
+    if (!query) {
+      return null;
+    }
+    const row = await query.first();
+    return row ? this.relatedForCurrentType()?.newFromRecord(row) ?? null : null;
+  }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(this.relatedQuery(), column, keyBy);
+  }
+  async value(column) {
+    return this.relatedQuery()?.value(column) ?? null;
+  }
+  relatedForCurrentType() {
     const type = String(this.parent.get(this.relation.morphTypeKey) ?? "");
+    return this.relatedByType[type];
+  }
+  relatedQuery() {
     const id = this.parent.get(this.relation.morphIdKey);
-    const related = this.relatedByType[type];
+    const related = this.relatedForCurrentType();
     if (!related || id === null || id === undefined) {
       return null;
     }
     const table = related.repository().getTable();
-    const row = await related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({ [table.primaryKey]: id, ...this.extraWhere })).first();
-    return row ? related.newFromRecord(row) : null;
+    return related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({ [table.primaryKey]: id, ...this.extraWhere }));
   }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
@@ -1007,10 +1113,7 @@ class HasManyThroughRelationQuery {
     return { sql, params: extra.params };
   }
   async get() {
-    const rows = await this.related.repository().withConnection(this.parent.getRepository().getConnection()).findHasManyThrough(this.parent.get(this.relation.localKey), this.relation, {
-      ...this.extraOptions,
-      where: this.extraWhere
-    });
+    const rows = await this.farRows();
     return rows.map((row) => this.related.newFromRecord(row));
   }
   async first() {
@@ -1021,6 +1124,20 @@ class HasManyThroughRelationQuery {
     const rows = await this.get();
     return rows.length;
   }
+  async pluck(column, keyBy) {
+    const rows = await this.farRows();
+    return keyBy === undefined ? projectPluck(rows, column) : projectPluck(rows, column, keyBy);
+  }
+  async value(column) {
+    const values = await this.limit(1).pluck(column);
+    return values[0] ?? null;
+  }
+  async farRows() {
+    return this.related.repository().withConnection(this.parent.getRepository().getConnection()).findHasManyThrough(this.parent.get(this.relation.localKey), this.relation, {
+      ...this.extraOptions,
+      where: this.extraWhere
+    });
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -1476,6 +1593,10 @@ function applyCasts(values, casts, direction) {
   }
   return result;
 }
+function castPluckedValue(modelClass, column, value) {
+  const cast = modelStatics(modelClass).$casts?.[column];
+  return cast ? hydrateValue(value, cast) : value;
+}
 function applyTimestampsOnCreate(columns, values, enabled) {
   if (!enabled) {
     return values;
@@ -1630,6 +1751,25 @@ class ModelQuery {
     const models = await this.get();
     return models[0] ?? null;
   }
+  async count() {
+    return this.query.count();
+  }
+  async pluck(column, keyBy) {
+    if (keyBy === undefined) {
+      const values = await this.query.pluck(column);
+      return values.map((value) => castPluckedValue(this.modelClass, column, value));
+    }
+    const keyed = await this.query.pluck(column, keyBy);
+    const result = new Map;
+    for (const [key, value] of keyed) {
+      result.set(castPluckedValue(this.modelClass, keyBy, key), castPluckedValue(this.modelClass, column, value));
+    }
+    return result;
+  }
+  async value(column) {
+    const value = await this.query.value(column);
+    return castPluckedValue(this.modelClass, column, value);
+  }
   async find(id) {
     const primaryKey = resolveModelRepository(this.modelClass).getTable().primaryKey;
     return this.where({ [primaryKey]: id }).first();
@@ -1877,6 +2017,16 @@ class Model {
   static where(where) {
     return Model.query.call(this).where(where);
   }
+  static async count() {
+    return Model.query.call(this).count();
+  }
+  static pluck(column, keyBy) {
+    const query = Model.query.call(this);
+    return keyBy === undefined ? query.pluck(column) : query.pluck(column, keyBy);
+  }
+  static value(column) {
+    return Model.query.call(this).value(column);
+  }
   static async firstWhere(where, options = {}) {
     let query = Model.query.call(this).where(where);
     if (options.orderBy) {

package/dist/entries/database/repositoryQuery.js

@@ -1,4 +1,28 @@
 // @bun
+// ../../src/core/database/pluck.ts
+function uniqueColumnSelect(table, columns) {
+  const seen = new Set;
+  const select = [];
+  for (const column of columns) {
+    if (seen.has(column)) {
+      continue;
+    }
+    seen.add(column);
+    select.push({ kind: "column", table, column, as: column });
+  }
+  return select;
+}
+function projectPluck(rows, column, keyBy) {
+  if (keyBy === undefined) {
+    return rows.map((row) => row[column]);
+  }
+  const keyed = new Map;
+  for (const row of rows) {
+    keyed.set(row[keyBy], row[column]);
+  }
+  return keyed;
+}
+
 // ../../src/core/database/query.ts
 import { currentSqlDialect } from "@getstrata/core/database/dialect";
 function quoteIdentifier(identifier) {
@@ -875,6 +899,28 @@ class RepositoryQuery {
   async count() {
     return await this.repository.count(this.buildOptions());
   }
+  async pluck(column, keyBy) {
+    const rows = await this.repository.findAll({
+      ...this.buildOptions(),
+      select: uniqueColumnSelect(this.repository.getTable().name, keyBy === undefined || keyBy === column ? [column] : [column, keyBy])
+    });
+    if (keyBy === undefined) {
+      return projectPluck(rows, column);
+    }
+    return projectPluck(rows, column, keyBy);
+  }
+  async value(column) {
+    const rows = await this.repository.findAll({
+      ...this.buildOptions(),
+      select: uniqueColumnSelect(this.repository.getTable().name, [column]),
+      limit: 1
+    });
+    const row = rows[0];
+    if (row === undefined) {
+      return null;
+    }
+    return row[column];
+  }
   async attachToRows(rows) {
     return await this.attach(rows);
   }
@@ -980,5 +1026,7 @@ class RepositoryQuery {
   }
 }
 export {
-  RepositoryQuery
+  RepositoryQuery,
+  projectPluck,
+  uniqueColumnSelect
 };

package/dist/framework/public-api.d.ts

@@ -52,7 +52,7 @@ export { createDatabaseQueryProxy } from "../core/database/queryProxy.ts";
 export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "../core/database/relationships.ts";
 export { belongsTo, belongsToMany, hasMany, hasManyThrough, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasManyThroughRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } from "../core/database/relationships.ts";
 export { repositoryConnection, resolveRepositoryConnection, } from "../core/database/repositoryConnection.ts";
-export { RepositoryQuery } from "../core/database/repositoryQuery.ts";
+export { projectPluck, RepositoryQuery, uniqueColumnSelect, } from "../core/database/repositoryQuery.ts";
 export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "../core/database/schema/index.ts";
 export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "../core/database/schema/index.ts";
 export { loadSeedersFromDirectory, runSeedersFromDirectory, } from "../core/database/seeders/runner.ts";

package/dist/index.js

@@ -2857,6 +2857,30 @@ function indexMorphToRelation(children, parentsByType, relation) {
   return result;
 }
 
+// ../../src/core/database/pluck.ts
+function uniqueColumnSelect(table, columns) {
+  const seen = new Set;
+  const select = [];
+  for (const column of columns) {
+    if (seen.has(column)) {
+      continue;
+    }
+    seen.add(column);
+    select.push({ kind: "column", table, column, as: column });
+  }
+  return select;
+}
+function projectPluck(rows, column, keyBy) {
+  if (keyBy === undefined) {
+    return rows.map((row) => row[column]);
+  }
+  const keyed = new Map;
+  for (const row of rows) {
+    keyed.set(row[keyBy], row[column]);
+  }
+  return keyed;
+}
+
 // ../../src/core/database/whereBuilder.ts
 class WhereBuilder {
   nodes = [];
@@ -3054,6 +3078,28 @@ class RepositoryQuery {
   async count() {
     return await this.repository.count(this.buildOptions());
   }
+  async pluck(column, keyBy) {
+    const rows = await this.repository.findAll({
+      ...this.buildOptions(),
+      select: uniqueColumnSelect(this.repository.getTable().name, keyBy === undefined || keyBy === column ? [column] : [column, keyBy])
+    });
+    if (keyBy === undefined) {
+      return projectPluck(rows, column);
+    }
+    return projectPluck(rows, column, keyBy);
+  }
+  async value(column) {
+    const rows = await this.repository.findAll({
+      ...this.buildOptions(),
+      select: uniqueColumnSelect(this.repository.getTable().name, [column]),
+      limit: 1
+    });
+    const row = rows[0];
+    if (row === undefined) {
+      return null;
+    }
+    return row[column];
+  }
   async attachToRows(rows) {
     return await this.attach(rows);
   }
@@ -3882,6 +3928,12 @@ function ownerId(owner, ownerKey) {
 function thenGet(get, onfulfilled, onrejected) {
   return get().then(onfulfilled ?? undefined, onrejected ?? undefined);
 }
+function pluckFromQuery(query, column, keyBy) {
+  if (!query) {
+    return Promise.resolve(keyBy === undefined ? [] : new Map);
+  }
+  return keyBy === undefined ? query.pluck(column) : query.pluck(column, keyBy);
+}
 
 class HasManyRelationQuery {
   parent;
@@ -3947,6 +3999,12 @@ class HasManyRelationQuery {
   async count() {
     return this.scopedQuery().count();
   }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(this.scopedQuery(), column, keyBy);
+  }
+  async value(column) {
+    return this.scopedQuery().value(column);
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -4012,6 +4070,13 @@ class HasOneRelationQuery {
   async count() {
     return this.inner.count();
   }
+  async pluck(column, keyBy) {
+    const query = this.inner.limit(1);
+    return keyBy === undefined ? query.pluck(column) : query.pluck(column, keyBy);
+  }
+  async value(column) {
+    return this.inner.limit(1).value(column);
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -4058,6 +4123,23 @@ class BelongsToRelationQuery {
     return { sql, params: extra.params };
   }
   async get() {
+    const query = this.relatedQuery();
+    if (!query) {
+      return null;
+    }
+    const row = await query.first();
+    return row ? this.related.newFromRecord(row) : null;
+  }
+  async first() {
+    return this.get();
+  }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(this.relatedQuery(), column, keyBy);
+  }
+  async value(column) {
+    return this.relatedQuery()?.value(column) ?? null;
+  }
+  relatedQuery() {
     const foreign = this.parent.get(this.relation.foreignKey);
     if (foreign === null || foreign === undefined) {
       return null;
@@ -4067,11 +4149,7 @@ class BelongsToRelationQuery {
     if (this.extraOptions.orderBy) {
       query = query.orderBy(this.extraOptions.orderBy);
     }
-    const row = await query.first();
-    return row ? this.related.newFromRecord(row) : null;
-  }
-  async first() {
-    return this.get();
+    return query;
   }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
@@ -4159,6 +4237,31 @@ class BelongsToManyRelationQuery {
     const rows = await this.connection().unsafe(`SELECT COUNT(*) AS count FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1`, [parentId]);
     return Number(rows[0]?.count ?? 0);
   }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(await this.relatedQuery(), column, keyBy);
+  }
+  async value(column) {
+    const query = await this.relatedQuery();
+    return query ? query.value(column) : null;
+  }
+  async relatedQuery() {
+    const parentId = this.parent.get(this.relation.parentKey);
+    const pivotRows = await this.connection().unsafe(`SELECT * FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1`, [parentId]);
+    if (pivotRows.length === 0) {
+      return null;
+    }
+    const relatedIds = [
+      ...new Set(pivotRows.map((row) => row[this.relation.relatedPivotKey]))
+    ];
+    let query = this.related.repository().withConnection(this.connection()).query(asWhere({
+      [this.relation.relatedKey]: relatedIds,
+      ...this.extraWhere
+    }));
+    if (this.extraOptions.orderBy) {
+      query = query.orderBy(this.extraOptions.orderBy);
+    }
+    return query;
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -4242,13 +4345,15 @@ class MorphManyRelationQuery {
     const sql = `SELECT 1 FROM ${quoteIdentifier(childTable)} WHERE ${qualifyColumn(childTable, this.relation.morphIdKey)} = ${qualifyColumn(parentTable, this.relation.localKey)}${extraSql ? ` AND ${extraSql}` : ""}`;
     return { sql, params: extra.params };
   }
-  async get() {
-    const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
-    const rows = await repository.query(asWhere({
+  scopedQuery() {
+    return this.related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({
       [this.relation.morphTypeKey]: this.relation.morphType,
       [this.relation.morphIdKey]: this.parent.get(this.relation.localKey),
       ...this.extraWhere
-    })).get();
+    }));
+  }
+  async get() {
+    const rows = await this.scopedQuery().get();
     return rows.map((row) => this.related.newFromRecord(row));
   }
   async first() {
@@ -4256,12 +4361,13 @@ class MorphManyRelationQuery {
     return rows[0] ?? null;
   }
   async count() {
-    const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
-    return repository.query(asWhere({
-      [this.relation.morphTypeKey]: this.relation.morphType,
-      [this.relation.morphIdKey]: this.parent.get(this.relation.localKey),
-      ...this.extraWhere
-    })).count();
+    return this.scopedQuery().count();
+  }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(this.scopedQuery(), column, keyBy);
+  }
+  async value(column) {
+    return this.scopedQuery().value(column);
   }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
@@ -4312,6 +4418,12 @@ class MorphOneRelationQuery {
   async count() {
     return this.inner.count();
   }
+  async pluck(column, keyBy) {
+    return keyBy === undefined ? this.inner.pluck(column) : this.inner.pluck(column, keyBy);
+  }
+  async value(column) {
+    return this.inner.value(column);
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -4360,15 +4472,31 @@ class MorphToRelationQuery {
     };
   }
   async get() {
+    const query = this.relatedQuery();
+    if (!query) {
+      return null;
+    }
+    const row = await query.first();
+    return row ? this.relatedForCurrentType()?.newFromRecord(row) ?? null : null;
+  }
+  async pluck(column, keyBy) {
+    return pluckFromQuery(this.relatedQuery(), column, keyBy);
+  }
+  async value(column) {
+    return this.relatedQuery()?.value(column) ?? null;
+  }
+  relatedForCurrentType() {
     const type = String(this.parent.get(this.relation.morphTypeKey) ?? "");
+    return this.relatedByType[type];
+  }
+  relatedQuery() {
     const id = this.parent.get(this.relation.morphIdKey);
-    const related = this.relatedByType[type];
+    const related = this.relatedForCurrentType();
     if (!related || id === null || id === undefined) {
       return null;
     }
     const table = related.repository().getTable();
-    const row = await related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({ [table.primaryKey]: id, ...this.extraWhere })).first();
-    return row ? related.newFromRecord(row) : null;
+    return related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({ [table.primaryKey]: id, ...this.extraWhere }));
   }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
@@ -4415,10 +4543,7 @@ class HasManyThroughRelationQuery {
     return { sql, params: extra.params };
   }
   async get() {
-    const rows = await this.related.repository().withConnection(this.parent.getRepository().getConnection()).findHasManyThrough(this.parent.get(this.relation.localKey), this.relation, {
-      ...this.extraOptions,
-      where: this.extraWhere
-    });
+    const rows = await this.farRows();
     return rows.map((row) => this.related.newFromRecord(row));
   }
   async first() {
@@ -4429,6 +4554,20 @@ class HasManyThroughRelationQuery {
     const rows = await this.get();
     return rows.length;
   }
+  async pluck(column, keyBy) {
+    const rows = await this.farRows();
+    return keyBy === undefined ? projectPluck(rows, column) : projectPluck(rows, column, keyBy);
+  }
+  async value(column) {
+    const values = await this.limit(1).pluck(column);
+    return values[0] ?? null;
+  }
+  async farRows() {
+    return this.related.repository().withConnection(this.parent.getRepository().getConnection()).findHasManyThrough(this.parent.get(this.relation.localKey), this.relation, {
+      ...this.extraOptions,
+      where: this.extraWhere
+    });
+  }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
   }
@@ -4641,6 +4780,10 @@ function applyCasts(values, casts, direction) {
   }
   return result;
 }
+function castPluckedValue(modelClass, column, value) {
+  const cast = modelStatics(modelClass).$casts?.[column];
+  return cast ? hydrateValue(value, cast) : value;
+}
 function applyTimestampsOnCreate(columns, values, enabled) {
   if (!enabled) {
     return values;
@@ -4795,6 +4938,25 @@ class ModelQuery {
     const models = await this.get();
     return models[0] ?? null;
   }
+  async count() {
+    return this.query.count();
+  }
+  async pluck(column, keyBy) {
+    if (keyBy === undefined) {
+      const values = await this.query.pluck(column);
+      return values.map((value) => castPluckedValue(this.modelClass, column, value));
+    }
+    const keyed = await this.query.pluck(column, keyBy);
+    const result = new Map;
+    for (const [key, value] of keyed) {
+      result.set(castPluckedValue(this.modelClass, keyBy, key), castPluckedValue(this.modelClass, column, value));
+    }
+    return result;
+  }
+  async value(column) {
+    const value = await this.query.value(column);
+    return castPluckedValue(this.modelClass, column, value);
+  }
   async find(id) {
     const primaryKey = resolveModelRepository(this.modelClass).getTable().primaryKey;
     return this.where({ [primaryKey]: id }).first();
@@ -5042,6 +5204,16 @@ class Model {
   static where(where) {
     return Model.query.call(this).where(where);
   }
+  static async count() {
+    return Model.query.call(this).count();
+  }
+  static pluck(column, keyBy) {
+    const query = Model.query.call(this);
+    return keyBy === undefined ? query.pluck(column) : query.pluck(column, keyBy);
+  }
+  static value(column) {
+    return Model.query.call(this).value(column);
+  }
   static async firstWhere(where, options = {}) {
     let query = Model.query.call(this).where(where);
     if (options.orderBy) {
@@ -10183,6 +10355,7 @@ export {
   parseQualifiedColumn,
   pivotTableName,
   policyGate,
+  projectPluck,
   prometheusRegistry,
   qualifyColumn,
   queue,
@@ -10300,6 +10473,7 @@ export {
   toResourceCollection,
   traceContextStorage,
   trustForwardedFor,
+  uniqueColumnSelect,
   unregisterNamedConnection,
   useSqlDialect,
   validateObject,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",