@getstrata/core 1.0.5 → 1.0.7

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @getstrata/core changelog
 
+## 1.0.7
+
+## 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/baseRepository.d.ts

@@ -28,6 +28,7 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
         perPage: number;
     } & Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<PaginatedResult<TEntity>>;
     chunk(count: number, callback: (rows: TEntity[]) => Promise<boolean | void>, options?: Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<void>;
+    chunkById(count: number, callback: (rows: TEntity[]) => Promise<boolean | undefined>, options?: Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset" | "orderBy">): Promise<void>;
     cursorPaginate(options: {
         perPage: number;
         cursor?: TEntity[PrimaryKey];
@@ -38,6 +39,9 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     findByIdOrThrow(id: TEntity[PrimaryKey], errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
     findByIds(ids: readonly TEntity[PrimaryKey][]): Promise<TEntity[]>;
     firstOrNull(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where" | "limit">): Promise<TEntity | null>;
+    upsert(values: MutationValues<TEntity>, conflictColumns: readonly (keyof TEntity & string)[], updateColumns?: readonly (keyof TEntity & string)[]): Promise<TEntity | null>;
+    incrementById(id: TEntity[PrimaryKey], column: keyof TEntity & string, amount?: number, extra?: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
+    decrementById(id: TEntity[PrimaryKey], column: keyof TEntity & string, amount?: number, extra?: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
     create(values: MutationValues<TEntity>): Promise<TEntity>;
     updateById(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
     updateByIdOrThrow(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>, errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
@@ -53,6 +57,11 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     protected countWhere(where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed" | "joins" | "groupBy">, whereNodes?: readonly WhereNode<TEntity>[]): Promise<number>;
     protected averageColumn(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
     protected averageExpression(expression: string, alias: string, where?: QueryWhere<TEntity>): Promise<number>;
+    sum(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
+    avg(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
+    min(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
+    max(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
+    private aggregateColumn;
     protected pluckNumberValues(expression: string, alias: string, options?: QueryOptions<TEntity>): Promise<number[]>;
     protected countGroupedBy<K extends keyof TEntity & string>(column: K, where?: QueryWhere<TEntity>): Promise<Array<{
         value: TEntity[K] | null;

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

@@ -10,6 +10,8 @@ interface SqlDialect {
     ilikeOperator(): "ILIKE" | "LIKE";
     nullsLastSuffix(): string;
     castToText(expression: string): string;
+    /** Conflict handling appended to an INSERT. Empty updates mean "do nothing". */
+    upsertSuffix(conflictColumns: readonly string[], updateColumns: readonly string[]): string;
 }
 declare function dialectFor(driver: DatabaseDriver): SqlDialect;
 declare function currentSqlDialect(): SqlDialect;

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

@@ -43,7 +43,20 @@ declare class ModelQuery {
     limit(limit: number): this;
     offset(offset: number): this;
     whereNull(column: string): this;
+    whereNotNull(column: string): this;
     whereIn(column: string, values: readonly unknown[]): this;
+    whereNotIn(column: string, values: readonly unknown[]): this;
+    groupBy(groupBy: QueryOptions<object>["groupBy"]): this;
+    having(having: QueryWhere<object>): this;
+    join(left: `${string}.${string}`, right: `${string}.${string}`): this;
+    leftJoin(left: `${string}.${string}`, right: `${string}.${string}`): this;
+    paginate(options: {
+        page: number;
+        perPage: number;
+    }): Promise<{
+        data: Array<Model<Record<string, unknown>, "id">>;
+        meta: Awaited<ReturnType<RepositoryQuery<Record<string, unknown>, "id">["paginate"]>>["meta"];
+    }>;
     whereExists(sql: string, params?: readonly unknown[]): this;
     whereNotExists(sql: string, params?: readonly unknown[]): this;
     whereHas(name: string, constrain?: (query: AnyRelationQuery) => void): this;
@@ -60,10 +73,16 @@ declare class ModelQuery {
     withTrashed(): this;
     onlyTrashed(): this;
     get(): Promise<Array<Model<Record<string, unknown>, "id">>>;
+    private hydrateRows;
     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>;
+    withCount(name: string, alias?: string): this;
     private constrainExists;
 }
 declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
@@ -129,6 +148,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/query.d.ts

@@ -44,6 +44,14 @@ declare function buildInsertQuery<TEntity extends object, PrimaryKey extends key
     text: string;
     params: unknown[];
 };
+declare function buildUpsertQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, values: MutationValues<TEntity>, conflictColumns: readonly string[], updateColumns?: readonly string[]): {
+    text: string;
+    params: unknown[];
+};
+declare function buildIncrementQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey], column: keyof TEntity & string, amount: number, extra?: UpdateValues<TEntity, PrimaryKey>): {
+    text: string;
+    params: unknown[];
+};
 declare function buildUpdateQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): {
     text: string;
     params: unknown[];
@@ -60,4 +68,4 @@ declare function buildDeleteByIdQuery<TEntity extends object, PrimaryKey extends
     text: string;
     params: unknown[];
 };
-export { assertSafeProjectionExpression, buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, };
+export { assertSafeProjectionExpression, buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildIncrementQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildUpsertQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, };

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

@@ -17,6 +17,8 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     limit(limit: number): this;
     whereNull(column: keyof TEntity & string): this;
     whereNotNull(column: keyof TEntity & string): this;
+    whereNotIn(column: keyof TEntity & string, values: readonly unknown[]): this;
+    withSubqueryCount(alias: string, sql: string, params?: readonly unknown[]): this;
     whereIn(column: keyof TEntity & string, values: readonly unknown[]): this;
     whereExists(sql: string, params?: readonly unknown[]): this;
     whereNotExists(sql: string, params?: readonly unknown[]): this;
@@ -37,6 +39,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 +52,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/core/database/types.d.ts

@@ -2,7 +2,9 @@ type DatabaseComparable = string | number | Date;
 type DatabaseScalar = DatabaseComparable | boolean | null;
 type QueryOperator = {
     eq?: DatabaseScalar;
+    ne?: DatabaseScalar;
     in?: readonly DatabaseScalar[];
+    notIn?: readonly DatabaseScalar[];
     gt?: DatabaseComparable;
     gte?: DatabaseComparable;
     lt?: DatabaseComparable;
@@ -42,6 +44,11 @@ type QuerySelectItem = {
     kind: "literalText";
     value: string;
     as: string;
+} | {
+    kind: "subqueryCount";
+    sql: string;
+    params: readonly unknown[];
+    as: string;
 } | {
     kind: "tsRank";
     table: string;