mirror of
https://github.com/swc-project/swc.git
synced 2024-12-24 22:22:34 +03:00
bbaf619f63
swc_bundler: - [x] Fix wrapped esms. (denoland/deno#9307) - [x] Make test secure.
297 lines
5.5 KiB
TypeScript
297 lines
5.5 KiB
TypeScript
// Loaded from https://deno.land/x/denodb@v1.0.18/lib/query-builder.ts
|
|
|
|
|
|
import type { SQLQueryBuilder } from "../deps.ts";
|
|
import type { FieldAlias, FieldValue, Values } from "./data-types.ts";
|
|
import { Model, ModelDefaults, ModelFields, ModelSchema } from "./model.ts";
|
|
|
|
export type Query = string;
|
|
export type Operator = ">" | ">=" | "<" | "<=" | "=";
|
|
export type OrderDirection = "desc" | "asc";
|
|
export type QueryType =
|
|
| "create"
|
|
| "drop"
|
|
| "select"
|
|
| "insert"
|
|
| "update"
|
|
| "delete"
|
|
| "count"
|
|
| "min"
|
|
| "max"
|
|
| "avg"
|
|
| "sum";
|
|
|
|
export type JoinClause = {
|
|
joinTable: string;
|
|
originField: string;
|
|
targetField: string;
|
|
};
|
|
|
|
export type WhereClause = {
|
|
field: string;
|
|
operator: Operator;
|
|
value: FieldValue;
|
|
};
|
|
|
|
export type WhereInClause = {
|
|
field: string;
|
|
possibleValues: FieldValue[];
|
|
};
|
|
|
|
export type OrderByClauses = {
|
|
[field: string]: OrderDirection;
|
|
};
|
|
|
|
export type QueryDescription = {
|
|
schema: ModelSchema;
|
|
type?: QueryType;
|
|
table?: string;
|
|
select?: (string | FieldAlias)[];
|
|
orderBy?: OrderByClauses;
|
|
groupBy?: string;
|
|
wheres?: WhereClause[];
|
|
whereIn?: WhereInClause;
|
|
joins?: JoinClause[];
|
|
leftOuterJoins?: JoinClause[];
|
|
leftJoins?: JoinClause[];
|
|
aggregatorField?: string;
|
|
limit?: number;
|
|
offset?: number;
|
|
ifExists?: boolean;
|
|
fields?: ModelFields;
|
|
fieldsDefaults?: ModelDefaults;
|
|
timestamps?: boolean;
|
|
values?: Values | Values[];
|
|
};
|
|
|
|
export type QueryResult = {};
|
|
|
|
export type Builder = typeof SQLQueryBuilder;
|
|
|
|
/** Create queries descriptions. */
|
|
export class QueryBuilder {
|
|
_query: QueryDescription = { schema: Model };
|
|
|
|
/** Create a fresh new query. */
|
|
queryForSchema(schema: ModelSchema): QueryBuilder {
|
|
return new QueryBuilder().schema(schema);
|
|
}
|
|
|
|
schema(schema: ModelSchema) {
|
|
this._query.schema = schema;
|
|
return this;
|
|
}
|
|
|
|
toDescription(): QueryDescription {
|
|
return this._query;
|
|
}
|
|
|
|
table(table: string) {
|
|
this._query.table = table;
|
|
return this;
|
|
}
|
|
|
|
get() {
|
|
this._query.type = "select";
|
|
return this;
|
|
}
|
|
|
|
all() {
|
|
return this.get();
|
|
}
|
|
|
|
createTable(
|
|
fields: ModelFields,
|
|
fieldsDefaults: ModelDefaults,
|
|
{
|
|
withTimestamps,
|
|
ifNotExists,
|
|
}: {
|
|
withTimestamps: boolean;
|
|
ifNotExists: boolean;
|
|
},
|
|
) {
|
|
this._query.type = "create";
|
|
this._query.ifExists = ifNotExists ? false : true;
|
|
this._query.fields = fields;
|
|
this._query.fieldsDefaults = fieldsDefaults;
|
|
this._query.timestamps = withTimestamps;
|
|
return this;
|
|
}
|
|
|
|
dropIfExists() {
|
|
this._query.type = "drop";
|
|
this._query.ifExists = true;
|
|
return this;
|
|
}
|
|
|
|
select(...fields: (string | FieldAlias)[]) {
|
|
this._query.select = fields;
|
|
return this;
|
|
}
|
|
|
|
create(values: Values[]) {
|
|
this._query.type = "insert";
|
|
this._query.values = values;
|
|
return this;
|
|
}
|
|
|
|
find(field: string, possibleValues: FieldValue[]) {
|
|
this._query.type = "select";
|
|
this._query.whereIn = {
|
|
field,
|
|
possibleValues,
|
|
};
|
|
return this;
|
|
}
|
|
|
|
orderBy(
|
|
field: string,
|
|
orderDirection: OrderDirection,
|
|
) {
|
|
if (!this._query.orderBy) {
|
|
this._query.orderBy = {};
|
|
}
|
|
this._query.orderBy[field] = orderDirection;
|
|
return this;
|
|
}
|
|
|
|
groupBy(field: string) {
|
|
this._query.groupBy = field;
|
|
return this;
|
|
}
|
|
|
|
limit(limit: number) {
|
|
this._query.limit = limit;
|
|
return this;
|
|
}
|
|
|
|
offset(offset: number) {
|
|
this._query.offset = offset;
|
|
return this;
|
|
}
|
|
|
|
where(
|
|
field: string,
|
|
operator: Operator,
|
|
value: FieldValue,
|
|
) {
|
|
if (!this._query.wheres) {
|
|
this._query.wheres = [];
|
|
}
|
|
|
|
const whereClause = {
|
|
field,
|
|
operator,
|
|
value,
|
|
};
|
|
|
|
const existingWhereForFieldIndex = this._query.wheres.findIndex((where) =>
|
|
where.field === field
|
|
);
|
|
|
|
if (existingWhereForFieldIndex === -1) {
|
|
this._query.wheres.push(whereClause);
|
|
} else {
|
|
this._query.wheres[existingWhereForFieldIndex] = whereClause;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
update(values: Values) {
|
|
this._query.type = "update";
|
|
this._query.values = values;
|
|
return this;
|
|
}
|
|
|
|
delete() {
|
|
this._query.type = "delete";
|
|
return this;
|
|
}
|
|
|
|
join(
|
|
joinTable: string,
|
|
originField: string,
|
|
targetField: string,
|
|
) {
|
|
if (!this._query.joins) {
|
|
this._query.joins = [];
|
|
}
|
|
|
|
this._query.joins.push({
|
|
joinTable,
|
|
originField,
|
|
targetField,
|
|
});
|
|
|
|
return this;
|
|
}
|
|
|
|
leftOuterJoin(
|
|
joinTable: string,
|
|
originField: string,
|
|
targetField: string,
|
|
) {
|
|
if (!this._query.leftOuterJoins) {
|
|
this._query.leftOuterJoins = [];
|
|
}
|
|
|
|
this._query.leftOuterJoins.push({
|
|
joinTable,
|
|
originField,
|
|
targetField,
|
|
});
|
|
|
|
return this;
|
|
}
|
|
|
|
leftJoin(
|
|
joinTable: string,
|
|
originField: string,
|
|
targetField: string,
|
|
) {
|
|
if (!this._query.leftJoins) {
|
|
this._query.leftJoins = [];
|
|
}
|
|
|
|
this._query.leftJoins.push({
|
|
joinTable,
|
|
originField,
|
|
targetField,
|
|
});
|
|
|
|
return this;
|
|
}
|
|
|
|
count(field: string) {
|
|
this._query.type = "count";
|
|
this._query.aggregatorField = field;
|
|
return this;
|
|
}
|
|
|
|
min(field: string) {
|
|
this._query.type = "min";
|
|
this._query.aggregatorField = field;
|
|
return this;
|
|
}
|
|
|
|
max(field: string) {
|
|
this._query.type = "max";
|
|
this._query.aggregatorField = field;
|
|
return this;
|
|
}
|
|
|
|
sum(field: string) {
|
|
this._query.type = "sum";
|
|
this._query.aggregatorField = field;
|
|
return this;
|
|
}
|
|
|
|
avg(field: string) {
|
|
this._query.type = "avg";
|
|
this._query.aggregatorField = field;
|
|
return this;
|
|
}
|
|
}
|