New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@ff00ff/mammoth

Package Overview
Dependencies
Maintainers
2
Versions
45
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@ff00ff/mammoth - npm Package Compare versions

Comparing version 1.0.0-rc.5 to 1.0.0-rc.6

.build/with.d.ts
.build/with.js

15

.build/column.d.ts
import { Token } from './tokens';
import { InternalExpression } from './expression';
import { Expression } from './expression';
import { TableDefinition } from './table';

@@ -13,4 +13,12 @@ export interface ColumnDefinition<DataType, IsNotNull extends boolean, HasDefault extends boolean> {

export declare const makeColumnDefinition: <DataType, IsNotNull extends boolean, HasDefault extends boolean>(dataType: string) => ColumnDefinition<DataType, IsNotNull, HasDefault>;
export interface Column<Name, TableName, DataType, IsNotNull extends boolean, HasDefault extends boolean, JoinType> extends InternalExpression<Name, DataType, IsNotNull> {
_columnBrand: any;
export declare class Column<Name extends string, TableName, DataType, IsNotNull extends boolean, HasDefault extends boolean, JoinType> extends Expression<DataType, IsNotNull, Name> {
private readonly columnName;
private readonly tableName;
private readonly originalColumnName;
private _columnBrand;
/** @internal */
getSnakeCaseName(): string;
/** @internal */
getName(): Name;
constructor(columnName: Name, tableName: TableName, originalColumnName: string | undefined);
as<AliasName extends string>(alias: AliasName): Column<AliasName, TableName, DataType, IsNotNull, HasDefault, JoinType>;

@@ -20,2 +28,1 @@ /** @internal */

}
export declare const makeColumn: <ColumnName, TableName, DataType, IsNotNull extends boolean, HasDefault extends boolean>(columnName: ColumnName, tableName: TableName, originalColumnName: string | undefined) => Column<ColumnName, TableName, DataType, IsNotNull, HasDefault, undefined>;

82

.build/column.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeColumn = exports.makeColumnDefinition = void 0;
exports.Column = exports.makeColumnDefinition = void 0;
const tokens_1 = require("./tokens");
const snake_case_1 = require("./naming/snake-case");
const expression_1 = require("./expression");
// import type { Table } from './table';
const snake_case_1 = require("./naming/snake-case");
const makeColumnDefinition = (dataType) => {
exports.makeColumnDefinition = (dataType) => {
return {

@@ -30,36 +29,43 @@ notNull() {

};
exports.makeColumnDefinition = makeColumnDefinition;
const makeColumn = (columnName, tableName, originalColumnName) => {
// TODO: either use some sort of AliasToken which we can later strip. Or pass some sort of option
// to the token generation so we can choose if we want named or unnamed.
const snakeCaseColumnName = snake_case_1.toSnakeCase(columnName);
return {
_columnBrand: undefined,
...expression_1.makeExpression(originalColumnName
class Column extends expression_1.Expression {
constructor(columnName, tableName, originalColumnName) {
super(originalColumnName
? [new tokens_1.StringToken(`${tableName}.${snake_case_1.toSnakeCase(originalColumnName)}`)]
: [new tokens_1.StringToken(`${tableName}.${snakeCaseColumnName}`)]),
as(alias) {
return exports.makeColumn(alias, tableName, columnName);
},
toTokens(includeAlias = false) {
if (includeAlias) {
const snakeCaseColumnName = snake_case_1.toSnakeCase(columnName);
return originalColumnName
? [
new tokens_1.StringToken(`${tableName}.${snake_case_1.toSnakeCase(originalColumnName)}`),
new tokens_1.AliasToken(columnName),
]
: snakeCaseColumnName === columnName
? [new tokens_1.StringToken(`${tableName}.${snakeCaseColumnName}`)]
: [
new tokens_1.StringToken(`${tableName}.${snakeCaseColumnName}`),
new tokens_1.AliasToken(columnName),
];
}
return originalColumnName
? [new tokens_1.StringToken(`${tableName}.${snake_case_1.toSnakeCase(originalColumnName)}`)]
: [new tokens_1.StringToken(`${tableName}.${snakeCaseColumnName}`)];
},
};
};
exports.makeColumn = makeColumn;
: [new tokens_1.StringToken(`${tableName}.${snake_case_1.toSnakeCase(columnName)}`)], columnName);
this.columnName = columnName;
this.tableName = tableName;
this.originalColumnName = originalColumnName;
}
/** @internal */
getSnakeCaseName() {
return snake_case_1.toSnakeCase(this.columnName);
}
/** @internal */
getName() {
return this.columnName;
}
as(alias) {
return new Column(alias, this.tableName, this.columnName);
}
/** @internal */
toTokens(includeAlias) {
const snakeCaseColumnName = snake_case_1.toSnakeCase(this.columnName);
if (includeAlias) {
return this.originalColumnName
? [
new tokens_1.StringToken(`${this.tableName}.${snake_case_1.toSnakeCase(this.originalColumnName)}`),
new tokens_1.StringToken(snake_case_1.wrapQuotes(this.columnName)),
]
: snakeCaseColumnName === this.columnName
? [new tokens_1.StringToken(`${this.tableName}.${snakeCaseColumnName}`)]
: [
new tokens_1.StringToken(`${this.tableName}.${snakeCaseColumnName}`),
new tokens_1.StringToken(snake_case_1.wrapQuotes(this.columnName)),
];
}
return this.originalColumnName
? [new tokens_1.StringToken(`${this.tableName}.${snake_case_1.toSnakeCase(this.originalColumnName)}`)]
: [new tokens_1.StringToken(`${this.tableName}.${snakeCaseColumnName}`)];
}
}
exports.Column = Column;

9

.build/condition.d.ts

@@ -1,8 +0,9 @@

import { Token } from "./tokens";
import { Token } from './tokens';
import { Expression } from './expression';
import { Query } from './query';
export interface Condition {
or(condition: Condition): Condition;
and(condition: Condition): Condition;
andNotExists(condition: Condition): Condition;
andExists(condition: Condition): Condition;
not(condition: Condition): Condition;
andNotExists(expression: Expression<any, any, any> | Query<any>): Condition;
andExists(expression: Expression<any, any, any> | Query<any>): Condition;
/** @internal */

@@ -9,0 +10,0 @@ toTokens(includeAlias?: boolean): Token[];

18

.build/condition.js

@@ -5,5 +5,5 @@ "use strict";

const tokens_1 = require("./tokens");
const makeCondition = (tokens) => {
const toGroup = (c) => {
const newTokens = c.toTokens();
exports.makeCondition = (tokens) => {
const toGroup = (e) => {
const newTokens = e.toTokens();
// Anything above 3 means we need to start grouping this in ( and ).

@@ -22,11 +22,8 @@ if (newTokens.length > 3) {

},
andNotExists(condition) {
return exports.makeCondition([...tokens, new tokens_1.StringToken(`AND NOT EXISTS`), toGroup(condition)]);
andNotExists(expression) {
return exports.makeCondition([...tokens, new tokens_1.StringToken(`AND NOT EXISTS`), toGroup(expression)]);
},
andExists(condition) {
return exports.makeCondition([...tokens, new tokens_1.StringToken(`AND EXISTS`), toGroup(condition)]);
andExists(expression) {
return exports.makeCondition([...tokens, new tokens_1.StringToken(`AND EXISTS`), toGroup(expression)]);
},
not(condition) {
return exports.makeCondition([...tokens, new tokens_1.StringToken(`NOT`), toGroup(condition)]);
},
toTokens() {

@@ -37,2 +34,1 @@ return tokens;

};
exports.makeCondition = makeCondition;

54

.build/data-types.js

@@ -5,37 +5,19 @@ "use strict";

const column_1 = require("./column");
const dataType = (dataType) => column_1.makeColumnDefinition(dataType);
exports.dataType = dataType;
const uuid = () => column_1.makeColumnDefinition(`uuid`);
exports.uuid = uuid;
const text = () => column_1.makeColumnDefinition(`text`);
exports.text = text;
const integer = () => column_1.makeColumnDefinition(`integer`);
exports.integer = integer;
const timestampWithTimeZone = () => column_1.makeColumnDefinition(`timestamp with time zone`);
exports.timestampWithTimeZone = timestampWithTimeZone;
const timestamptz = () => column_1.makeColumnDefinition(`timestamp with time zone`);
exports.timestamptz = timestamptz;
const citext = () => column_1.makeColumnDefinition(`citext`);
exports.citext = citext;
const caseInsensitiveText = () => column_1.makeColumnDefinition(`citext`);
exports.caseInsensitiveText = caseInsensitiveText;
const decimal = () => column_1.makeColumnDefinition(`decimal`);
exports.decimal = decimal;
const serial = () => column_1.makeColumnDefinition(`serial`);
exports.serial = serial;
const bigserial = () => column_1.makeColumnDefinition(`bigserial`);
exports.bigserial = bigserial;
const smallserial = () => column_1.makeColumnDefinition(`smallserial`);
exports.smallserial = smallserial;
const json = () => column_1.makeColumnDefinition(`json`);
exports.json = json;
const jsonb = () => column_1.makeColumnDefinition(`jsonb`);
exports.jsonb = jsonb;
const timestampWithoutTimeZone = () => column_1.makeColumnDefinition(`timestamp without time zone`);
exports.timestampWithoutTimeZone = timestampWithoutTimeZone;
const timestamp = () => column_1.makeColumnDefinition(`timestamp`);
exports.timestamp = timestamp;
const date = () => column_1.makeColumnDefinition(`date`);
exports.date = date;
const time = () => column_1.makeColumnDefinition(`time`);
exports.time = time;
exports.dataType = (dataType) => column_1.makeColumnDefinition(dataType);
exports.uuid = () => column_1.makeColumnDefinition(`uuid`);
exports.text = () => column_1.makeColumnDefinition(`text`);
exports.integer = () => column_1.makeColumnDefinition(`integer`);
exports.timestampWithTimeZone = () => column_1.makeColumnDefinition(`timestamp with time zone`);
exports.timestamptz = () => column_1.makeColumnDefinition(`timestamp with time zone`);
exports.citext = () => column_1.makeColumnDefinition(`citext`);
exports.caseInsensitiveText = () => column_1.makeColumnDefinition(`citext`);
exports.decimal = () => column_1.makeColumnDefinition(`decimal`);
exports.serial = () => column_1.makeColumnDefinition(`serial`);
exports.bigserial = () => column_1.makeColumnDefinition(`bigserial`);
exports.smallserial = () => column_1.makeColumnDefinition(`smallserial`);
exports.json = () => column_1.makeColumnDefinition(`json`);
exports.jsonb = () => column_1.makeColumnDefinition(`jsonb`);
exports.timestampWithoutTimeZone = () => column_1.makeColumnDefinition(`timestamp without time zone`);
exports.timestamp = () => column_1.makeColumnDefinition(`timestamp`);
exports.date = () => column_1.makeColumnDefinition(`date`);
exports.time = () => column_1.makeColumnDefinition(`time`);

5

.build/db.d.ts

@@ -13,4 +13,5 @@ import { Column, ColumnDefinition } from './column';

update: <T_2 extends unknown>(table: T_2) => {
set(values: T_2 extends Table<any, infer Columns_2> ? { [K in keyof Columns_2]?: (Columns_2[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? DataType | import("./expression").Expression<DataType, boolean> : DataType | import("./expression").Expression<DataType | undefined, boolean> | undefined : never) | undefined; } : never): import("./update").UpdateQuery<T_2, number, T_2 extends Table<any, infer Columns_3> ? Columns_3 : never>;
set(values: T_2 extends Table<any, infer Columns_2> ? { [K in keyof Columns_2]?: (Columns_2[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? DataType | import("./expression").Expression<DataType, boolean, any> : DataType | import("./expression").Expression<DataType | undefined, boolean, any> | undefined : never) | undefined; } : never): import("./update").UpdateQuery<T_2, number, T_2 extends Table<any, infer Columns_3> ? Columns_3 : never>;
};
} & { [TableName in keyof TableDefinitions]: TableDefinitions[TableName] extends TableDefinition<infer ColumnDefinitions> ? Table<TableName, { [K_1 in keyof ColumnDefinitions]: Column<K_1, TableName, ColumnDefinitions[K_1] extends ColumnDefinition<infer DataType_1, any, any> ? DataType_1 : never, ColumnDefinitions[K_1] extends ColumnDefinition<any, infer IsNotNull_1, any> ? IsNotNull_1 : never, ColumnDefinitions[K_1] extends ColumnDefinition<any, any, infer HasDefault> ? HasDefault : never, undefined>; }> : never; };
with: import("./with").WithFn;
} & { [TableName in keyof TableDefinitions]: TableDefinitions[TableName] extends TableDefinition<infer ColumnDefinitions> ? Table<TableName, { [K_1 in keyof ColumnDefinitions]: K_1 extends string ? Column<K_1, TableName, ColumnDefinitions[K_1] extends ColumnDefinition<infer DataType_1, any, any> ? DataType_1 : never, ColumnDefinitions[K_1] extends ColumnDefinition<any, infer IsNotNull_1, any> ? IsNotNull_1 : never, ColumnDefinitions[K_1] extends ColumnDefinition<any, any, infer HasDefault> ? HasDefault : never, undefined> : never; }> : never; };

5

.build/db.js

@@ -9,2 +9,3 @@ "use strict";

const update_1 = require("./update");
const with_1 = require("./with");
const snake_case_1 = require("./naming/snake-case");

@@ -18,3 +19,3 @@ const createTables = (tableDefinitions) => {

};
const defineDb = (tableDefinitions, queryExecutor) => {
exports.defineDb = (tableDefinitions, queryExecutor) => {
return {

@@ -25,5 +26,5 @@ select: select_1.makeSelect(queryExecutor),

update: update_1.makeUpdate(queryExecutor),
with: with_1.makeWith(queryExecutor),
...createTables(tableDefinitions),
};
};
exports.defineDb = defineDb;

5

.build/delete.d.ts

@@ -10,2 +10,3 @@ import { Token } from './tokens';

private readonly queryExecutor;
private readonly returningKeys;
private readonly table;

@@ -15,3 +16,5 @@ private readonly resultType;

private _deleteQueryBrand;
constructor(queryExecutor: QueryExecutorFn, table: T, resultType: ResultType, tokens: Token[]);
/** @internal */
getReturningKeys(): string[];
constructor(queryExecutor: QueryExecutorFn, returningKeys: string[], table: T, resultType: ResultType, tokens: Token[]);
then(onFulfilled?: ((value: Returning extends number ? number : ResultSet<DeleteQuery<T, Returning>, false>[]) => any | PromiseLike<any>) | undefined | null, onRejected?: ((reason: any) => void | PromiseLike<void>) | undefined | null): Promise<any>;

@@ -18,0 +21,0 @@ using(...fromItems: Table<any, any>[]): DeleteQuery<T, Returning>;

39

.build/delete.js

@@ -5,17 +5,15 @@ "use strict";

const tokens_1 = require("./tokens");
const data_1 = require("./data");
const query_1 = require("./query");
const makeDeleteFrom = (queryExecutor) => (table) => {
const tableData = data_1.getTableData(table);
return new DeleteQuery(queryExecutor, table, 'AFFECTED_COUNT', [
exports.makeDeleteFrom = (queryExecutor) => (table) => {
return new DeleteQuery(queryExecutor, [], table, 'AFFECTED_COUNT', [
new tokens_1.StringToken(`DELETE FROM`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
};
exports.makeDeleteFrom = makeDeleteFrom;
// https://www.postgresql.org/docs/12/sql-delete.html
class DeleteQuery extends query_1.Query {
constructor(queryExecutor, table, resultType, tokens) {
constructor(queryExecutor, returningKeys, table, resultType, tokens) {
super();
this.queryExecutor = queryExecutor;
this.returningKeys = returningKeys;
this.table = table;

@@ -25,2 +23,6 @@ this.resultType = resultType;

}
/** @internal */
getReturningKeys() {
return this.returningKeys;
}
then(onFulfilled, onRejected) {

@@ -35,8 +37,7 @@ const queryState = tokens_1.createQueryState(this.tokens);

using(...fromItems) {
return new DeleteQuery(this.queryExecutor, this.table, this.resultType, [
return new DeleteQuery(this.queryExecutor, [], this.table, this.resultType, [
...this.tokens,
new tokens_1.StringToken(`USING`),
new tokens_1.SeparatorToken(`,`, fromItems.map((fromItem) => {
const tableData = data_1.getTableData(fromItem);
return new tokens_1.StringToken(tableData.name);
return new tokens_1.StringToken(fromItem.getName());
})),

@@ -46,3 +47,3 @@ ]);

where(condition) {
return new DeleteQuery(this.queryExecutor, this.table, this.resultType, [
return new DeleteQuery(this.queryExecutor, [], this.table, this.resultType, [
...this.tokens,

@@ -54,3 +55,3 @@ new tokens_1.StringToken(`WHERE`),

whereCurrentOf(cursorName) {
return new DeleteQuery(this.queryExecutor, this.table, this.resultType, [
return new DeleteQuery(this.queryExecutor, [], this.table, this.resultType, [
...this.tokens,

@@ -61,13 +62,13 @@ new tokens_1.StringToken(`WHERE CURRENT OF`),

}
returning(...columns) {
return new DeleteQuery(this.queryExecutor, this.table, 'ROWS', [
returning(...columnNames) {
return new DeleteQuery(this.queryExecutor, columnNames, this.table, 'ROWS', [
...this.tokens,
new tokens_1.StringToken(`RETURNING`),
new tokens_1.SeparatorToken(`,`, columns.map((alias) => {
const columnData = data_1.getColumnData(this.table[alias]);
if (alias !== columnData.snakeCaseName) {
return new tokens_1.StringToken(`${columnData.snakeCaseName} "${alias}"`);
new tokens_1.SeparatorToken(`,`, columnNames.map((alias) => {
const column = this.table[alias];
if (alias !== column.getSnakeCaseName()) {
return new tokens_1.StringToken(`${column.getSnakeCaseName()} "${alias}"`);
}
else {
return new tokens_1.StringToken(columnData.snakeCaseName);
return new tokens_1.StringToken(column.getSnakeCaseName());
}

@@ -74,0 +75,0 @@ })),

60

.build/expression.d.ts

@@ -1,22 +0,28 @@

import { Condition } from "./condition";
import { Token } from "./tokens";
import { Query } from "./query";
export interface NamedExpression<Name, DataType, IsNotNull extends boolean> extends InternalExpression<Name, DataType, IsNotNull> {
as<NewName extends string>(name: NewName): NamedExpression<NewName, DataType, IsNotNull>;
}
export interface InternalExpression<Name, DataType, IsNotNull extends boolean> {
import { Token } from './tokens';
import { Condition } from './condition';
import { Query } from './query';
export declare class Expression<DataType, IsNotNull extends boolean, Name extends string> {
private readonly tokens;
private readonly name;
private readonly nameIsAlias;
private _expressionBrand;
/** @internal */
getName(): Name;
constructor(tokens: Token[], name: Name, nameIsAlias?: boolean);
private getDataTypeTokens;
as<AliasName extends string>(name: AliasName): Expression<DataType, IsNotNull, AliasName>;
isNull(): Condition;
isNotNull(): Condition;
asc(): Expression<DataType, IsNotNull>;
desc(): Expression<DataType, IsNotNull>;
nullsFirst(): Expression<DataType, IsNotNull>;
nullsLast(): Expression<DataType, IsNotNull>;
in(array: DataType[] | Expression<DataType, IsNotNull> | Query<any>): Condition;
notIn(value: DataType[] | Expression<DataType, IsNotNull> | Query<any>): Condition;
plus(value: DataType | Expression<DataType, IsNotNull>): Expression<DataType, IsNotNull>;
minus(value: DataType | Expression<DataType, IsNotNull>): Expression<DataType, IsNotNull>;
multiply(value: DataType | Expression<DataType, IsNotNull>): Expression<DataType, IsNotNull>;
divide(value: DataType | Expression<DataType, IsNotNull>): Expression<DataType, IsNotNull>;
modulo(value: DataType | Expression<DataType, IsNotNull>): Expression<DataType, IsNotNull>;
concat(value: DataType | Expression<DataType, IsNotNull>): Expression<DataType, IsNotNull>;
asc(): Expression<DataType, IsNotNull, '?column?'>;
desc(): Expression<DataType, IsNotNull, '?column?'>;
nullsFirst(): Expression<DataType, IsNotNull, '?column?'>;
nullsLast(): Expression<DataType, IsNotNull, '?column?'>;
in(array: DataType[] | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
notIn(array: DataType[] | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
plus(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
minus(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
multiply(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
divide(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
modulo(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
concat(value: DataType | Expression<DataType, IsNotNull, any>): Expression<DataType, IsNotNull, '?column?'>;
between(a: DataType, b: DataType): Condition;

@@ -28,13 +34,11 @@ betweenSymmetric(a: DataType, b: DataType): Condition;

ilike(value: DataType): Condition;
eq(value: DataType | Expression<DataType, IsNotNull>): Condition;
ne(value: DataType | Expression<DataType, IsNotNull>): Condition;
gt(value: DataType | Expression<DataType, IsNotNull>): Condition;
gte(value: DataType | Expression<DataType, IsNotNull>): Condition;
lt(value: DataType | Expression<DataType, IsNotNull>): Condition;
lte(value: DataType | Expression<DataType, IsNotNull>): Condition;
eq(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
ne(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
gt(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
gte(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
lt(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
lte(value: DataType | Expression<DataType, IsNotNull, any> | Query<any>): Condition;
orderBy(...expressions: Expression<any, any, any>[]): Expression<DataType, IsNotNull, '?column?'>;
/** @internal */
toTokens(includeAlias?: boolean): Token[];
}
export declare type Expression<DataType, IsNotNull extends boolean> = NamedExpression<'?column?', DataType, IsNotNull>;
export declare const makeNamedExpression: <Name extends string, DataType, IsNotNull extends boolean>(tokens: Token[]) => NamedExpression<Name, DataType, IsNotNull>;
export declare const makeExpression: <DataType>(tokens: Token[]) => Expression<DataType, true>;

301

.build/expression.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeExpression = exports.makeNamedExpression = void 0;
exports.Expression = void 0;
const tokens_1 = require("./tokens");
const condition_1 = require("./condition");
const tokens_1 = require("./tokens");
const query_1 = require("./query");
const makeNamedExpression = (tokens) => exports.makeExpression(tokens);
exports.makeNamedExpression = makeNamedExpression;
const makeExpression = (tokens) => {
//
const getDataTypeTokens = (value) => {
class Expression {
constructor(tokens, name, nameIsAlias = false) {
this.tokens = tokens;
this.name = name;
this.nameIsAlias = nameIsAlias;
}
/** @internal */
getName() {
return this.name;
}
getDataTypeTokens(value) {
if (value &&

@@ -16,141 +22,160 @@ typeof value === `object` &&

typeof value.toTokens === `function`) {
if (value instanceof query_1.Query) {
return [new tokens_1.GroupToken(value.toTokens())];
}
return value.toTokens();
}
return [new tokens_1.ParameterToken(value)];
};
return {
as(name) {
if (tokens.length > 2) {
return exports.makeExpression([new tokens_1.GroupToken(tokens), new tokens_1.StringToken(`"${name}"`)]);
}
return exports.makeExpression([...tokens, new tokens_1.StringToken(`"${name}"`)]);
},
isNull() {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`IS NULL`)]);
},
isNotNull() {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`IS NOT NULL`)]);
},
asc() {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`ASC`)]);
},
desc() {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`DESC`)]);
},
nullsFirst() {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`NULLS FIRST`)]);
},
nullsLast() {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`NULLS LAST`)]);
},
// IN ($1, $2, $3)
// IN foo.id
// IN (SELECT * FROM test)
in(array) {
if (array && ('toTokens' in array || array instanceof query_1.Query)) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`IN`), new tokens_1.GroupToken(array.toTokens())]);
}
else {
return condition_1.makeCondition([
...tokens,
new tokens_1.StringToken(`IN`),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(',', array.map((item) => new tokens_1.ParameterToken(item))),
]),
]);
}
},
notIn(array) {
if (array && ('toTokens' in array || array instanceof query_1.Query)) {
return condition_1.makeCondition([
...tokens,
new tokens_1.StringToken(`NOT IN`),
new tokens_1.GroupToken(array.toTokens()),
]);
}
else {
return condition_1.makeCondition([
...tokens,
new tokens_1.StringToken(`NOT IN`),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(',', array.map((item) => new tokens_1.ParameterToken(item))),
]),
]);
}
},
plus(value) {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`+`), ...getDataTypeTokens(value)]);
},
minus(value) {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`-`), ...getDataTypeTokens(value)]);
},
multiply(value) {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`*`), ...getDataTypeTokens(value)]);
},
divide(value) {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`/`), ...getDataTypeTokens(value)]);
},
modulo(value) {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`%`), ...getDataTypeTokens(value)]);
},
concat(value) {
return exports.makeExpression([...tokens, new tokens_1.StringToken(`||`), ...getDataTypeTokens(value)]);
},
between(a, b) {
}
as(name) {
if (this.tokens.length > 2) {
return new Expression([new tokens_1.GroupToken(this.tokens)], name, true);
}
return new Expression([...this.tokens], name, true);
}
isNull() {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`IS NULL`)]);
}
isNotNull() {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`IS NOT NULL`)]);
}
asc() {
return new Expression([...this.tokens, new tokens_1.StringToken(`ASC`)], '?column?');
}
desc() {
return new Expression([...this.tokens, new tokens_1.StringToken(`DESC`)], '?column?');
}
nullsFirst() {
return new Expression([...this.tokens, new tokens_1.StringToken(`NULLS FIRST`)], '?column?');
}
nullsLast() {
return new Expression([...this.tokens, new tokens_1.StringToken(`NULLS LAST`)], '?column?');
}
in(array) {
if (array && ('toTokens' in array || array instanceof query_1.Query)) {
return condition_1.makeCondition([
...tokens,
new tokens_1.StringToken(`BETWEEN`),
new tokens_1.ParameterToken(a),
new tokens_1.StringToken(`AND`),
new tokens_1.ParameterToken(b),
...this.tokens,
new tokens_1.StringToken(`IN`),
new tokens_1.GroupToken(array.toTokens()),
]);
},
betweenSymmetric(a, b) {
}
else {
return condition_1.makeCondition([
...tokens,
new tokens_1.StringToken(`BETWEEN SYMMETRIC`),
new tokens_1.ParameterToken(a),
new tokens_1.StringToken(`AND`),
new tokens_1.ParameterToken(b),
...this.tokens,
new tokens_1.StringToken(`IN`),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(',', array.map((item) => new tokens_1.ParameterToken(item))),
]),
]);
},
isDistinctFrom(a) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`IS DISTINCT FROM`), new tokens_1.ParameterToken(a)]);
},
isNotDistinctFrom(a) {
}
}
notIn(array) {
if (array && ('toTokens' in array || array instanceof query_1.Query)) {
return condition_1.makeCondition([
...tokens,
new tokens_1.StringToken(`IS NOT DISTINCT FROM`),
new tokens_1.ParameterToken(a),
...this.tokens,
new tokens_1.StringToken(`NOT IN`),
new tokens_1.GroupToken(array.toTokens()),
]);
},
like(value) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`LIKE`), new tokens_1.ParameterToken(value)]);
},
ilike(value) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`ILIKE`), new tokens_1.ParameterToken(value)]);
},
eq(value) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`=`), ...getDataTypeTokens(value)]);
},
ne(value) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`<>`), ...getDataTypeTokens(value)]);
},
gt(value) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`>`), ...getDataTypeTokens(value)]);
},
gte(value) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`>=`), ...getDataTypeTokens(value)]);
},
lt(value) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`<`), ...getDataTypeTokens(value)]);
},
lte(value) {
return condition_1.makeCondition([...tokens, new tokens_1.StringToken(`<=`), ...getDataTypeTokens(value)]);
},
toTokens() {
return tokens;
},
};
};
exports.makeExpression = makeExpression;
}
else {
return condition_1.makeCondition([
...this.tokens,
new tokens_1.StringToken(`NOT IN`),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(',', array.map((item) => new tokens_1.ParameterToken(item))),
]),
]);
}
}
plus(value) {
return new Expression([...this.tokens, new tokens_1.StringToken(`+`), ...this.getDataTypeTokens(value)], '?column?');
}
minus(value) {
return new Expression([...this.tokens, new tokens_1.StringToken(`-`), ...this.getDataTypeTokens(value)], '?column?');
}
multiply(value) {
return new Expression([...this.tokens, new tokens_1.StringToken(`*`), ...this.getDataTypeTokens(value)], '?column?');
}
divide(value) {
return new Expression([...this.tokens, new tokens_1.StringToken(`/`), ...this.getDataTypeTokens(value)], '?column?');
}
modulo(value) {
return new Expression([...this.tokens, new tokens_1.StringToken(`%`), ...this.getDataTypeTokens(value)], '?column?');
}
concat(value) {
return new Expression([...this.tokens, new tokens_1.StringToken(`||`), ...this.getDataTypeTokens(value)], '?column?');
}
between(a, b) {
return condition_1.makeCondition([
...this.tokens,
new tokens_1.StringToken(`BETWEEN`),
new tokens_1.ParameterToken(a),
new tokens_1.StringToken(`AND`),
new tokens_1.ParameterToken(b),
]);
}
betweenSymmetric(a, b) {
return condition_1.makeCondition([
...this.tokens,
new tokens_1.StringToken(`BETWEEN SYMMETRIC`),
new tokens_1.ParameterToken(a),
new tokens_1.StringToken(`AND`),
new tokens_1.ParameterToken(b),
]);
}
isDistinctFrom(a) {
return condition_1.makeCondition([
...this.tokens,
new tokens_1.StringToken(`IS DISTINCT FROM`),
new tokens_1.ParameterToken(a),
]);
}
isNotDistinctFrom(a) {
return condition_1.makeCondition([
...this.tokens,
new tokens_1.StringToken(`IS NOT DISTINCT FROM`),
new tokens_1.ParameterToken(a),
]);
}
like(value) {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`LIKE`), new tokens_1.ParameterToken(value)]);
}
ilike(value) {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`ILIKE`), new tokens_1.ParameterToken(value)]);
}
eq(value) {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`=`), ...this.getDataTypeTokens(value)]);
}
ne(value) {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`<>`), ...this.getDataTypeTokens(value)]);
}
gt(value) {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`>`), ...this.getDataTypeTokens(value)]);
}
gte(value) {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`>=`), ...this.getDataTypeTokens(value)]);
}
lt(value) {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`<`), ...this.getDataTypeTokens(value)]);
}
lte(value) {
return condition_1.makeCondition([...this.tokens, new tokens_1.StringToken(`<=`), ...this.getDataTypeTokens(value)]);
}
orderBy(...expressions) {
return new Expression([
...this.tokens,
new tokens_1.StringToken(`ORDER BY`),
new tokens_1.SeparatorToken(',', expressions.map((expression) => new tokens_1.CollectionToken(expression.toTokens()))),
], '?column?');
}
/** @internal */
toTokens(includeAlias) {
if (includeAlias && (this.nameIsAlias || this.name.match(/[A-Z]/))) {
// Some expression return a train_case name by default such as string_agg. We automatically
// convert these to camelCase equivalents e.g. stringAgg.
return [...this.tokens, new tokens_1.StringToken(`"${this.name}"`)];
}
return this.tokens;
}
}
exports.Expression = Expression;

11

.build/insert.d.ts

@@ -14,2 +14,3 @@ import { Token } from './tokens';

private readonly queryExecutor;
private readonly returningKeys;
private readonly table;

@@ -19,3 +20,5 @@ private readonly resultType;

private _insertQueryBrand;
constructor(queryExecutor: QueryExecutorFn, table: T, resultType: ResultType, tokens: Token[]);
/** @internal */
getReturningKeys(): string[];
constructor(queryExecutor: QueryExecutorFn, returningKeys: string[], table: T, resultType: ResultType, tokens: Token[]);
then(onFulfilled?: ((value: Returning extends number ? Returning : ResultSet<InsertQuery<T, Returning>, false>[]) => any | PromiseLike<any>) | undefined | null, onRejected?: ((reason: any) => void | PromiseLike<void>) | undefined | null): Promise<any>;

@@ -35,7 +38,7 @@ returning<C1 extends keyof TableColumns>(column1: C1): InsertQuery<T, GetReturning<TableColumns, C1>>;

doNothing(): InsertQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;
doUpdateSet(values: T extends Table<any, infer Columns_1> ? { [K in keyof Columns_1]?: (Columns_1[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? Query<any> | DataType | Expression<DataType, IsNotNull> : Query<any> | DataType | Expression<DataType, IsNotNull> | undefined : never) | undefined; } : never): InsertQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;
doUpdateSet(values: T extends Table<any, infer Columns_1> ? { [K in keyof Columns_1]?: (Columns_1[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? Query<any> | DataType | Expression<DataType, IsNotNull, any> : Query<any> | DataType | Expression<DataType, IsNotNull, any> | undefined : never) | undefined; } : never): InsertQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;
};
onConflict<ColumnNames extends T extends Table<any, infer Columns> ? (keyof Columns)[] : never>(...columnNames: ColumnNames): {
doNothing(): InsertQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;
doUpdateSet(values: T extends Table<any, infer Columns_1> ? { [K in keyof Columns_1]?: (Columns_1[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? Query<any> | DataType | Expression<DataType, IsNotNull> : Query<any> | DataType | Expression<DataType, IsNotNull> | undefined : never) | undefined; } : never): InsertQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;
doUpdateSet(values: T extends Table<any, infer Columns_1> ? { [K in keyof Columns_1]?: (Columns_1[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? Query<any> | DataType | Expression<DataType, IsNotNull, any> : Query<any> | DataType | Expression<DataType, IsNotNull, any> | undefined : never) | undefined; } : never): InsertQuery<T, number, T extends Table<any, infer Columns> ? Columns : never>;
};

@@ -50,3 +53,3 @@ /** @internal */

set(values: UpdateTable extends Table<any, infer Columns> ? {
[K in keyof Columns]?: Columns[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? DataType | Expression<DataType, boolean> : DataType | undefined | Expression<DataType | undefined, boolean> : never;
[K in keyof Columns]?: Columns[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? DataType | Expression<DataType, boolean, any> : DataType | undefined | Expression<DataType | undefined, boolean, any> : never;
} : never): UpdateQuery<UpdateTable, number>;

@@ -53,0 +56,0 @@ };

96

.build/insert.js

@@ -6,3 +6,2 @@ "use strict";

const select_1 = require("./select");
const data_1 = require("./data");
const delete_1 = require("./delete");

@@ -13,5 +12,6 @@ const query_1 = require("./query");

class InsertQuery extends query_1.Query {
constructor(queryExecutor, table, resultType, tokens) {
constructor(queryExecutor, returningKeys, table, resultType, tokens) {
super();
this.queryExecutor = queryExecutor;
this.returningKeys = returningKeys;
this.table = table;

@@ -21,2 +21,6 @@ this.resultType = resultType;

}
/** @internal */
getReturningKeys() {
return this.returningKeys;
}
then(onFulfilled, onRejected) {

@@ -30,13 +34,13 @@ const queryState = tokens_1.createQueryState(this.tokens);

}
returning(...columns) {
return new InsertQuery(this.queryExecutor, this.table, 'ROWS', [
returning(...columnNames) {
return new InsertQuery(this.queryExecutor, columnNames, this.table, 'ROWS', [
...this.tokens,
new tokens_1.StringToken(`RETURNING`),
new tokens_1.SeparatorToken(`,`, columns.map((alias) => {
const columnData = data_1.getColumnData(this.table[alias]);
if (alias !== columnData.snakeCaseName) {
return new tokens_1.StringToken(`${columnData.snakeCaseName} "${alias}"`);
new tokens_1.SeparatorToken(`,`, columnNames.map((alias) => {
const column = this.table[alias];
if (alias !== column.getSnakeCaseName()) {
return new tokens_1.StringToken(`${column.getSnakeCaseName()} "${alias}"`);
}
else {
return new tokens_1.StringToken(columnData.snakeCaseName);
return new tokens_1.StringToken(column.getSnakeCaseName());
}

@@ -47,3 +51,3 @@ })),

where(condition) {
return new InsertQuery(this.queryExecutor, this.table, this.resultType, [
return new InsertQuery(this.queryExecutor, this.returningKeys, this.table, this.resultType, [
...this.tokens,

@@ -58,3 +62,3 @@ new tokens_1.StringToken(`WHERE`),

doNothing() {
return new InsertQuery(self.queryExecutor, self.table, self.resultType, [
return new InsertQuery(self.queryExecutor, self.returningKeys, self.table, self.resultType, [
...self.tokens,

@@ -67,3 +71,3 @@ new tokens_1.StringToken(`ON CONFLICT ON CONSTRAINT`),

doUpdateSet(values) {
return new InsertQuery(self.queryExecutor, self.table, self.resultType, [
return new InsertQuery(self.queryExecutor, self.returningKeys, self.table, self.resultType, [
...self.tokens,

@@ -76,3 +80,2 @@ new tokens_1.StringToken(`ON CONFLICT ON CONSTRAINT`),

const value = values[columnName];
const columnData = data_1.getColumnData(column);
if (value &&

@@ -83,3 +86,3 @@ typeof value === `object` &&

return new tokens_1.CollectionToken([
new tokens_1.StringToken(columnData.snakeCaseName),
new tokens_1.StringToken(column.getSnakeCaseName()),
new tokens_1.StringToken(`=`),

@@ -92,3 +95,3 @@ // TODO: should we add a group here-o?

return new tokens_1.CollectionToken([
new tokens_1.StringToken(columnData.snakeCaseName),
new tokens_1.StringToken(column.getSnakeCaseName()),
new tokens_1.StringToken(`=`),

@@ -107,3 +110,3 @@ new tokens_1.ParameterToken(value),

doNothing() {
return new InsertQuery(self.queryExecutor, self.table, self.resultType, [
return new InsertQuery(self.queryExecutor, self.returningKeys, self.table, self.resultType, [
...self.tokens,

@@ -114,4 +117,3 @@ new tokens_1.StringToken(`ON CONFLICT`),

const column = self.table[columnName];
const columnData = data_1.getColumnData(column);
return new tokens_1.StringToken(columnData.snakeCaseName);
return new tokens_1.StringToken(column.getSnakeCaseName());
}))

@@ -123,3 +125,3 @@ : new tokens_1.EmptyToken(),

doUpdateSet(values) {
return new InsertQuery(self.queryExecutor, self.table, self.resultType, [
return new InsertQuery(self.queryExecutor, self.returningKeys, self.table, self.resultType, [
...self.tokens,

@@ -130,4 +132,3 @@ new tokens_1.StringToken(`ON CONFLICT`),

const column = self.table[columnName];
const columnData = data_1.getColumnData(column);
return new tokens_1.StringToken(columnData.snakeCaseName);
return new tokens_1.StringToken(column.getSnakeCaseName());
}))

@@ -139,3 +140,2 @@ : new tokens_1.EmptyToken(),

const value = values[columnName];
const columnData = data_1.getColumnData(column);
if (value &&

@@ -146,3 +146,3 @@ typeof value === `object` &&

return new tokens_1.CollectionToken([
new tokens_1.StringToken(columnData.snakeCaseName),
new tokens_1.StringToken(column.getSnakeCaseName()),
new tokens_1.StringToken(`=`),

@@ -155,3 +155,3 @@ // TODO: should we add a group here-o?

return new tokens_1.CollectionToken([
new tokens_1.StringToken(columnData.snakeCaseName),
new tokens_1.StringToken(column.getSnakeCaseName()),
new tokens_1.StringToken(`=`),

@@ -172,12 +172,11 @@ new tokens_1.ParameterToken(value),

exports.InsertQuery = InsertQuery;
const makeInsertInto = (queryExecutor) => (table, columnNames) => {
const insertTableData = data_1.getTableData(table);
exports.makeInsertInto = (queryExecutor) => (table, columnNames) => {
return {
select: select_1.makeSelect(queryExecutor, [
new tokens_1.StringToken(`INSERT INTO`),
new tokens_1.StringToken(insertTableData.name),
new tokens_1.StringToken(table.getName()),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(`,`, (columnNames === null || columnNames === void 0 ? void 0 : columnNames.map((columnName) => {
const columnData = data_1.getColumnData(table[columnName]);
return new tokens_1.StringToken(columnData.snakeCaseName);
const column = table[columnName];
return new tokens_1.StringToken(column.getSnakeCaseName());
})) || []),

@@ -187,15 +186,13 @@ ]),

deleteFrom(deleteTable) {
const deleteTableData = data_1.getTableData(deleteTable);
const insertTableData = data_1.getTableData(table);
return new delete_1.DeleteQuery(queryExecutor, deleteTable, 'AFFECTED_COUNT', [
return new delete_1.DeleteQuery(queryExecutor, [], deleteTable, 'AFFECTED_COUNT', [
new tokens_1.StringToken(`INSERT INTO`),
new tokens_1.StringToken(insertTableData.name),
new tokens_1.StringToken(table.getName()),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(`,`, columnNames.map((columnName) => {
const columnData = data_1.getColumnData(table[columnName]);
return new tokens_1.StringToken(columnData.snakeCaseName);
const column = table[columnName];
return new tokens_1.StringToken(column.getSnakeCaseName());
})),
]),
new tokens_1.StringToken(`DELETE FROM`),
new tokens_1.StringToken(deleteTableData.name),
new tokens_1.StringToken(deleteTable.getName()),
]);

@@ -206,21 +203,20 @@ },

set(values) {
const updateTableData = data_1.getTableData(updateTable);
const keys = Object.keys(values);
return new update_1.UpdateQuery(queryExecutor, table, 'AFFECTED_COUNT', [
return new update_1.UpdateQuery(queryExecutor, [], table, 'AFFECTED_COUNT', [
new tokens_1.StringToken(`INSERT INTO`),
new tokens_1.StringToken(insertTableData.name),
new tokens_1.StringToken(table.getName()),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(`,`, columnNames.map((columnName) => {
const columnData = data_1.getColumnData(table[columnName]);
return new tokens_1.StringToken(columnData.snakeCaseName);
const column = table[columnName];
return new tokens_1.StringToken(column.getSnakeCaseName());
})),
]),
new tokens_1.StringToken(`UPDATE`),
new tokens_1.StringToken(updateTableData.name),
new tokens_1.StringToken(updateTable.getName()),
new tokens_1.StringToken(`SET`),
new tokens_1.SeparatorToken(`,`, keys.map((key) => {
const columnData = data_1.getColumnData(table[key]);
const column = table[key];
const value = values[key];
return new tokens_1.CollectionToken([
new tokens_1.StringToken(columnData.snakeCaseName),
new tokens_1.StringToken(column.getSnakeCaseName()),
new tokens_1.StringToken(`=`),

@@ -237,5 +233,5 @@ value && typeof value === `object` && 'toTokens' in value

defaultValues() {
return new InsertQuery(queryExecutor, table, 'AFFECTED_COUNT', [
return new InsertQuery(queryExecutor, [], table, 'AFFECTED_COUNT', [
new tokens_1.StringToken(`INSERT INTO`),
new tokens_1.StringToken(insertTableData.name),
new tokens_1.StringToken(table.getName()),
new tokens_1.StringToken(`DEFAULT VALUES`),

@@ -249,10 +245,9 @@ ]);

values(values) {
return new InsertQuery(queryExecutor, table, 'AFFECTED_COUNT', [
return new InsertQuery(queryExecutor, [], table, 'AFFECTED_COUNT', [
new tokens_1.StringToken(`INSERT INTO`),
new tokens_1.StringToken(insertTableData.name),
new tokens_1.StringToken(table.getName()),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(`,`, Object.keys(values).map((columnName) => {
const column = table[columnName];
const columnData = data_1.getColumnData(column);
return new tokens_1.StringToken(columnData.snakeCaseName);
return new tokens_1.StringToken(column.getSnakeCaseName());
})),

@@ -279,2 +274,1 @@ ]),

};
exports.makeInsertInto = makeInsertInto;

1

.build/naming/snake-case.d.ts

@@ -0,1 +1,2 @@

export declare const wrapQuotes: (string: string) => string;
export declare const toSnakeCase: (string: string) => string;

6

.build/naming/snake-case.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.toSnakeCase = void 0;
const toSnakeCase = (string) => string
exports.toSnakeCase = exports.wrapQuotes = void 0;
exports.wrapQuotes = (string) => (string.match(/[A-Z]/) ? `"${string}"` : string);
exports.toSnakeCase = (string) => string
.replace(/\W+/g, ' ')

@@ -9,2 +10,1 @@ .split(/ |\B(?=[A-Z])/)

.join('_');
exports.toSnakeCase = toSnakeCase;

4

.build/query.d.ts

@@ -1,2 +0,2 @@

import { Token } from "./tokens";
import { Token } from './tokens';
export declare abstract class Query<Returning> {

@@ -6,2 +6,4 @@ private _queryBrand;

abstract toTokens(includeAlias?: boolean): Token[];
/** @internal */
abstract getReturningKeys(): string[];
}

16

.build/result-set.d.ts
import type { Column } from './column';
import { DeleteQuery } from './delete';
import type { Expression } from './expression';
import { GetDataType } from './types';
import { InsertQuery } from './insert';
import type { NamedExpression } from './expression';
import { Query } from "./query";
import { Query } from './query';
import { SelectQuery } from './select';
import { UpdateQuery } from './update';
export declare class GetDataType<Type, IsNull> {
private _;
}
export declare type ResultSetDataType<Type, IsNotNull> = IsNotNull extends true ? Type : Type | undefined;
export declare type ResultSet<T extends Query<any>, Test extends boolean> = T extends SelectQuery<infer Returning> ? {
[K in keyof Returning]: Returning[K] extends Column<any, any, infer D, infer N, any, infer JoinType> ? Extract<JoinType, 'left-join'> extends never ? Extract<JoinType, 'left-side-of-right-join'> extends never ? Extract<JoinType, 'full-join'> extends never ? N extends true ? Test extends true ? GetDataType<D, true> : ResultSetDataType<D, true> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Returning[K] extends NamedExpression<any, infer D, infer IsNotNull> ? Test extends true ? GetDataType<D, IsNotNull> : ResultSetDataType<D, IsNotNull> : Returning[K] extends Query<{}> ? ResultSet<Returning[K], Test>[keyof ResultSet<Returning[K], Test>] : never;
[K in keyof Returning]: Returning[K] extends Column<any, any, infer D, infer N, any, infer JoinType> ? Extract<JoinType, 'left-join'> extends never ? Extract<JoinType, 'left-side-of-right-join'> extends never ? Extract<JoinType, 'full-join'> extends never ? N extends true ? Test extends true ? GetDataType<D, true> : ResultSetDataType<D, true> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Returning[K] extends Expression<infer D, infer IsNotNull, any> ? Test extends true ? GetDataType<D, IsNotNull> : ResultSetDataType<D, IsNotNull> : Returning[K] extends Query<{}> ? ResultSet<Returning[K], Test>[keyof ResultSet<Returning[K], Test>] : never;
} : T extends DeleteQuery<any, infer Returning> ? {
[K in keyof Returning]: Returning[K] extends Column<any, any, infer D, infer N, any, infer JoinType> ? Extract<JoinType, 'left-join'> extends never ? Extract<JoinType, 'left-side-of-right-join'> extends never ? Extract<JoinType, 'full-join'> extends never ? N extends true ? Test extends true ? GetDataType<D, true> : ResultSetDataType<D, true> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Returning[K] extends NamedExpression<any, infer D, infer IsNotNull> ? Test extends true ? GetDataType<D, IsNotNull> : ResultSetDataType<D, IsNotNull> : Returning[K] extends Query<{}> ? ResultSet<Returning[K], Test>[keyof ResultSet<Returning[K], Test>] : never;
[K in keyof Returning]: Returning[K] extends Column<any, any, infer D, infer N, any, infer JoinType> ? Extract<JoinType, 'left-join'> extends never ? Extract<JoinType, 'left-side-of-right-join'> extends never ? Extract<JoinType, 'full-join'> extends never ? N extends true ? Test extends true ? GetDataType<D, true> : ResultSetDataType<D, true> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Returning[K] extends Expression<infer D, infer IsNotNull, any> ? Test extends true ? GetDataType<D, IsNotNull> : ResultSetDataType<D, IsNotNull> : Returning[K] extends Query<{}> ? ResultSet<Returning[K], Test>[keyof ResultSet<Returning[K], Test>] : never;
} : T extends UpdateQuery<any, infer Returning> ? {
[K in keyof Returning]: Returning[K] extends Column<any, any, infer D, infer N, any, infer JoinType> ? Extract<JoinType, 'left-join'> extends never ? Extract<JoinType, 'left-side-of-right-join'> extends never ? Extract<JoinType, 'full-join'> extends never ? N extends true ? Test extends true ? GetDataType<D, true> : ResultSetDataType<D, true> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Returning[K] extends NamedExpression<any, infer D, infer IsNotNull> ? Test extends true ? GetDataType<D, IsNotNull> : ResultSetDataType<D, IsNotNull> : Returning[K] extends Query<{}> ? ResultSet<Returning[K], Test>[keyof ResultSet<Returning[K], Test>] : never;
[K in keyof Returning]: Returning[K] extends Column<any, any, infer D, infer N, any, infer JoinType> ? Extract<JoinType, 'left-join'> extends never ? Extract<JoinType, 'left-side-of-right-join'> extends never ? Extract<JoinType, 'full-join'> extends never ? N extends true ? Test extends true ? GetDataType<D, true> : ResultSetDataType<D, true> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Returning[K] extends Expression<infer D, infer IsNotNull, any> ? Test extends true ? GetDataType<D, IsNotNull> : ResultSetDataType<D, IsNotNull> : Returning[K] extends Query<{}> ? ResultSet<Returning[K], Test>[keyof ResultSet<Returning[K], Test>] : never;
} : T extends InsertQuery<any, infer Returning> ? {
[K in keyof Returning]: Returning[K] extends Column<any, any, infer D, infer N, any, infer JoinType> ? Extract<JoinType, 'left-join'> extends never ? Extract<JoinType, 'left-side-of-right-join'> extends never ? Extract<JoinType, 'full-join'> extends never ? N extends true ? Test extends true ? GetDataType<D, true> : ResultSetDataType<D, true> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Returning[K] extends NamedExpression<any, infer D, infer IsNotNull> ? Test extends true ? GetDataType<D, IsNotNull> : ResultSetDataType<D, IsNotNull> : Returning[K] extends Query<{}> ? ResultSet<Returning[K], Test>[keyof ResultSet<Returning[K], Test>] : never;
[K in keyof Returning]: Returning[K] extends Column<any, any, infer D, infer N, any, infer JoinType> ? Extract<JoinType, 'left-join'> extends never ? Extract<JoinType, 'left-side-of-right-join'> extends never ? Extract<JoinType, 'full-join'> extends never ? N extends true ? Test extends true ? GetDataType<D, true> : ResultSetDataType<D, true> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Test extends true ? GetDataType<D, false> : ResultSetDataType<D, false> : Returning[K] extends Expression<infer D, infer IsNotNull, any> ? Test extends true ? GetDataType<D, IsNotNull> : ResultSetDataType<D, IsNotNull> : Returning[K] extends Query<{}> ? ResultSet<Returning[K], Test>[keyof ResultSet<Returning[K], Test>] : never;
} : never;

4

.build/result-set.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GetDataType = void 0;
class GetDataType {
}
exports.GetDataType = GetDataType;

16

.build/select.d.ts
import { Token } from './tokens';
import { Expression, NamedExpression } from './expression';
import { Table, TableDefinition } from './table';
import { Column } from './column';
import { Condition } from './condition';
import { Expression } from './expression';
import { Query } from './query';

@@ -20,3 +20,3 @@ import { QueryExecutorFn } from './types';

};
declare type GetSelectableName<S> = S extends Column<infer A2, string, any, boolean, boolean, any> ? A2 : S extends NamedExpression<infer A1, any, boolean> ? A1 : S extends SelectQuery<infer Columns> ? keyof Columns : never;
declare type GetSelectableName<S> = S extends Column<infer A2, string, any, boolean, boolean, any> ? A2 : S extends Expression<any, boolean, infer A1> ? A1 : S extends SelectQuery<infer Columns> ? keyof Columns : never;
declare type GetSelectable<C extends Selectable> = {

@@ -29,6 +29,10 @@ [K in GetSelectableName<C>]: C;

private readonly queryExecutor;
private readonly returningKeys;
private readonly tokens;
private _selectQueryBrand;
constructor(queryExecutor: QueryExecutorFn, tokens: Token[]);
/** @internal */
getReturningKeys(): string[];
constructor(queryExecutor: QueryExecutorFn, returningKeys: string[], tokens: Token[]);
then(onFulfilled?: ((value: ResultSet<SelectQuery<Columns>, false>[]) => any | PromiseLike<any>) | undefined | null, onRejected?: ((reason: any) => void | PromiseLike<void>) | undefined | null): Promise<any>;
private newSelectQuery;
from<T extends Table<any, any>>(fromItem: T): T extends TableDefinition<any> ? never : SelectQuery<Columns>;

@@ -53,6 +57,6 @@ join(table: Table<any, any>): SelectQuery<Columns>;

where(condition: Condition): SelectQuery<Columns>;
groupBy(...expressions: Expression<any, any>[]): SelectQuery<Columns>;
groupBy(...expressions: Expression<any, any, any>[]): SelectQuery<Columns>;
having(...conditions: Condition[]): SelectQuery<Columns>;
window(): SelectQuery<Columns>;
orderBy(...expressions: Expression<any, any>[]): SelectQuery<Columns>;
orderBy(...expressions: Expression<any, any, any>[]): SelectQuery<Columns>;
limit(limit: number | 'ALL'): SelectQuery<Columns>;

@@ -65,3 +69,3 @@ offset(start: number): SelectQuery<Columns>;

}
declare type Selectable = NamedExpression<any, any, any> | SelectQuery<any> | Column<any, any, any, boolean, boolean, any>;
declare type Selectable = Expression<any, any, any> | SelectQuery<any> | Column<any, any, any, boolean, boolean, any>;
export interface SelectFn {

@@ -68,0 +72,0 @@ <C1 extends Selectable>(c1: C1): SelectQuery<GetSelectable<C1>>;

121

.build/select.js

@@ -6,10 +6,14 @@ "use strict";

const query_1 = require("./query");
const data_1 = require("./data");
// https://www.postgresql.org/docs/12/sql-select.html
class SelectQuery extends query_1.Query {
constructor(queryExecutor, tokens) {
constructor(queryExecutor, returningKeys, tokens) {
super();
this.queryExecutor = queryExecutor;
this.returningKeys = returningKeys;
this.tokens = tokens;
}
/** @internal */
getReturningKeys() {
return this.returningKeys;
}
then(onFulfilled, onRejected) {

@@ -21,75 +25,70 @@ const queryState = tokens_1.createQueryState(this.tokens);

}
newSelectQuery(tokens) {
return new SelectQuery(this.queryExecutor, this.returningKeys, tokens);
}
// [ FROM from_item [, ...] ]
from(fromItem) {
const tableData = data_1.getTableData(fromItem);
return new SelectQuery(this.queryExecutor, [
const table = fromItem;
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`FROM`),
tableData.originalName
? new tokens_1.StringToken(`${tableData.originalName} "${tableData.name}"`)
: new tokens_1.StringToken(tableData.name),
table.getOriginalName()
? new tokens_1.StringToken(`${table.getOriginalName()} "${table.getName()}"`)
: new tokens_1.StringToken(table.getName()),
]);
}
join(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`JOIN`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
}
innerJoin(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`INNER JOIN`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
}
leftOuterJoin(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`LEFT OUTER JOIN`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
}
leftJoin(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`INNER JOIN`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
}
rightOuterJoin(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`RIGHT OUTER JOIN`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
}
rightJoin(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`RIGHT JOIN`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
}
fullOuterJoin(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`FULL OUTER JOIN`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
}
fullJoin(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`FULL JOIN`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);

@@ -99,23 +98,19 @@ }

crossJoin(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`CROSS JOIN`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
}
forUpdate() {
return new SelectQuery(this.queryExecutor, [...this.tokens, new tokens_1.StringToken(`FOR UPDATE`)]);
return this.newSelectQuery([...this.tokens, new tokens_1.StringToken(`FOR UPDATE`)]);
}
forNoKeyUpdate() {
return new SelectQuery(this.queryExecutor, [
...this.tokens,
new tokens_1.StringToken(`FOR NO KEY UPDATE`),
]);
return this.newSelectQuery([...this.tokens, new tokens_1.StringToken(`FOR NO KEY UPDATE`)]);
}
forShare() {
return new SelectQuery(this.queryExecutor, [...this.tokens, new tokens_1.StringToken(`FOR SHARE`)]);
return this.newSelectQuery([...this.tokens, new tokens_1.StringToken(`FOR SHARE`)]);
}
forKeyShare() {
return new SelectQuery(this.queryExecutor, [...this.tokens, new tokens_1.StringToken(`FOR KEY SHARE`)]);
return this.newSelectQuery([...this.tokens, new tokens_1.StringToken(`FOR KEY SHARE`)]);
}

@@ -127,3 +122,3 @@ /** @internal */

on(joinCondition) {
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,

@@ -135,3 +130,3 @@ new tokens_1.StringToken(`ON`),

using(...columns) {
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,

@@ -146,7 +141,3 @@ new tokens_1.StringToken(`USING`),

where(condition) {
return new SelectQuery(this.queryExecutor, [
...this.tokens,
new tokens_1.StringToken(`WHERE`),
...condition.toTokens(),
]);
return this.newSelectQuery([...this.tokens, new tokens_1.StringToken(`WHERE`), ...condition.toTokens()]);
}

@@ -161,3 +152,3 @@ // [ GROUP BY grouping_element [, ...] ]

groupBy(...expressions) {
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,

@@ -170,3 +161,3 @@ new tokens_1.StringToken(`GROUP BY`),

having(...conditions) {
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,

@@ -184,3 +175,3 @@ new tokens_1.StringToken(`HAVING`),

orderBy(...expressions) {
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,

@@ -194,6 +185,6 @@ new tokens_1.StringToken(`ORDER BY`),

if (limit === `ALL`) {
return new SelectQuery(this.queryExecutor, [...this.tokens, new tokens_1.StringToken(`LIMIT ALL`)]);
return this.newSelectQuery([...this.tokens, new tokens_1.StringToken(`LIMIT ALL`)]);
}
else {
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,

@@ -207,3 +198,3 @@ new tokens_1.StringToken(`LIMIT`),

offset(start) {
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,

@@ -215,3 +206,3 @@ new tokens_1.StringToken(`OFFSET`),

fetch(count) {
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,

@@ -224,19 +215,24 @@ new tokens_1.StringToken(`FETCH FIRST`),

of(table) {
const tableData = data_1.getTableData(table);
return new SelectQuery(this.queryExecutor, [
return this.newSelectQuery([
...this.tokens,
new tokens_1.StringToken(`OF`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
]);
}
nowait() {
return new SelectQuery(this.queryExecutor, [...this.tokens, new tokens_1.StringToken(`NOWAIT`)]);
return this.newSelectQuery([...this.tokens, new tokens_1.StringToken(`NOWAIT`)]);
}
skipLocked() {
return new SelectQuery(this.queryExecutor, [...this.tokens, new tokens_1.StringToken(`SKIP LOCKED`)]);
return this.newSelectQuery([...this.tokens, new tokens_1.StringToken(`SKIP LOCKED`)]);
}
}
exports.SelectQuery = SelectQuery;
const makeSelect = (queryExecutor, initialTokens) => (...columns) => {
return new SelectQuery(queryExecutor, [
exports.makeSelect = (queryExecutor, initialTokens) => (...columns) => {
const returningKeys = columns.map((column) => {
if (column instanceof query_1.Query) {
return column.getReturningKeys()[0];
}
return column.getName();
});
return new SelectQuery(queryExecutor, returningKeys, [
...(initialTokens || []),

@@ -253,2 +249,1 @@ new tokens_1.StringToken(`SELECT`),

};
exports.makeSelect = makeSelect;

28

.build/sql-functions.d.ts
import { Condition } from './condition';
import { Expression, NamedExpression } from './expression';
export declare const any: <T>(array: T[]) => Expression<T, true>;
export declare const now: () => Expression<Date, true>;
export declare const count: (expression?: Expression<any, any> | undefined) => NamedExpression<'count', string, true>;
export declare const min: <DataType, IsNotNull extends boolean>(expression: Expression<DataType, IsNotNull>) => NamedExpression<"min", DataType, IsNotNull>;
export declare const max: <DataType, IsNotNull extends boolean>(expression: Expression<DataType, IsNotNull>) => NamedExpression<"max", DataType, IsNotNull>;
export declare const avg: <DataType, IsNotNull extends boolean>(expression: Expression<DataType, IsNotNull>) => NamedExpression<"avg", DataType, true>;
export declare const sum: <DataType, IsNotNull extends boolean>(expression: Expression<DataType, IsNotNull>) => NamedExpression<"sum", DataType, IsNotNull>;
import { Expression } from './expression';
import { Query } from './query';
export declare const stringAgg: (expression: Expression<string, boolean, any>, delimiter: string, ...orderBy: Expression<any, any, any>[]) => Expression<string, false, 'stringAgg'>;
export declare const bitAnd: (expression: Expression<number, boolean, any>) => Expression<number, false, "bitAnd">;
export declare const bitOr: (expression: Expression<number, boolean, any>) => Expression<number, false, "bitOr">;
export declare const boolAnd: (expression: Expression<boolean, boolean, any>) => Expression<number, false, "boolAnd">;
export declare const boolOr: (expression: Expression<boolean, boolean, any>) => Expression<number, false, "boolOr">;
export declare const every: (expression: Expression<boolean, boolean, any>) => Expression<number, false, "every">;
export declare const arrayAgg: <DataType>(expression: Expression<DataType, boolean, any>) => Expression<DataType[], false, "arrayAgg">;
export declare const count: (expression?: Expression<any, any, any> | undefined) => Expression<string, true, 'count'>;
export declare const min: <DataType>(expression: Expression<DataType, boolean, any>) => Expression<DataType, false, "min">;
export declare const max: <DataType>(expression: Expression<DataType, boolean, any>) => Expression<DataType, false, "max">;
export declare const avg: (expression: Expression<number, boolean, any>) => Expression<number, false, "avg">;
export declare const sum: (expression: Expression<number, boolean, any>) => Expression<number, false, "sum">;
export declare const xmlagg: <DataType>(expression: Expression<DataType, boolean, any>) => Expression<number, false, "xmlagg">;
export declare const not: (condition: Condition) => Condition;

@@ -14,1 +21,6 @@ export declare const and: (condition: Condition) => Condition;

export declare const group: (condition: Condition) => Condition;
export declare const any: <T>(array: T[]) => Expression<T, true, "?column?">;
export declare const now: () => Expression<Date, true, "now">;
export declare const exists: (expression: Expression<any, any, any> | Query<any>) => Condition;
export declare const notExists: (expression: Expression<any, any, any> | Query<any>) => Condition;
export declare const coalesce: <DataType>(...expressions: (DataType | Expression<DataType, boolean, any>)[]) => Expression<DataType, true, "coalesce">;

93

.build/sql-functions.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.group = exports.or = exports.and = exports.not = exports.sum = exports.avg = exports.max = exports.min = exports.count = exports.now = exports.any = void 0;
exports.coalesce = exports.notExists = exports.exists = exports.now = exports.any = exports.group = exports.or = exports.and = exports.not = exports.xmlagg = exports.sum = exports.avg = exports.max = exports.min = exports.count = exports.arrayAgg = exports.every = exports.boolOr = exports.boolAnd = exports.bitOr = exports.bitAnd = exports.stringAgg = void 0;
const tokens_1 = require("./tokens");
const condition_1 = require("./condition");
const expression_1 = require("./expression");
const tokens_1 = require("./tokens");
const any = (array) => expression_1.makeExpression([new tokens_1.StringToken(`ANY`), new tokens_1.GroupToken([new tokens_1.ParameterToken(array)])]);
exports.any = any;
const now = () => expression_1.makeExpression([new tokens_1.StringToken(`NOW()`)]);
exports.now = now;
const count = (expression) => {
exports.stringAgg = (expression, delimiter, ...orderBy) => {
return new expression_1.Expression([
new tokens_1.StringToken(`string_agg`),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(',', [
new tokens_1.CollectionToken(expression.toTokens(false)),
new tokens_1.CollectionToken([
new tokens_1.ParameterToken(delimiter),
orderBy
? new tokens_1.CollectionToken([
new tokens_1.StringToken(`ORDER BY`),
new tokens_1.SeparatorToken(`,`, orderBy.map((expression) => new tokens_1.CollectionToken(expression.toTokens()))),
])
: new tokens_1.EmptyToken(),
]),
]),
]),
], 'stringAgg');
};
exports.bitAnd = (expression) => new expression_1.Expression([new tokens_1.StringToken(`bit_and`), new tokens_1.GroupToken(expression.toTokens(false))], 'bitAnd');
exports.bitOr = (expression) => new expression_1.Expression([new tokens_1.StringToken(`bit_or`), new tokens_1.GroupToken(expression.toTokens(false))], 'bitOr');
exports.boolAnd = (expression) => new expression_1.Expression([new tokens_1.StringToken(`bool_and`), new tokens_1.GroupToken(expression.toTokens(false))], 'boolAnd');
exports.boolOr = (expression) => new expression_1.Expression([new tokens_1.StringToken(`bool_or`), new tokens_1.GroupToken(expression.toTokens(false))], 'boolOr');
exports.every = (expression) => new expression_1.Expression([new tokens_1.StringToken(`every`), new tokens_1.GroupToken(expression.toTokens(false))], 'every');
exports.arrayAgg = (expression) => new expression_1.Expression([new tokens_1.StringToken(`array_agg`), new tokens_1.GroupToken(expression.toTokens(false))], 'arrayAgg');
exports.count = (expression) => {
if (!expression) {
return expression_1.makeNamedExpression([new tokens_1.StringToken(`COUNT(*)`)]);
return new expression_1.Expression([new tokens_1.StringToken(`COUNT(*)`)], 'count');
}
const tokens = expression.toTokens(false);
return expression_1.makeNamedExpression([new tokens_1.StringToken(`COUNT`), new tokens_1.GroupToken(tokens)]);
const tokens = expression.toTokens();
return new expression_1.Expression([new tokens_1.StringToken(`COUNT`), new tokens_1.GroupToken(tokens)], 'count');
};
exports.count = count;
const min = (expression) => expression_1.makeNamedExpression([
new tokens_1.StringToken(`MIN`),
new tokens_1.GroupToken(expression.toTokens()),
]);
exports.min = min;
const max = (expression) => expression_1.makeNamedExpression([
new tokens_1.StringToken(`MAX`),
new tokens_1.GroupToken(expression.toTokens()),
]);
exports.max = max;
const avg = (expression) => expression_1.makeNamedExpression([
new tokens_1.StringToken(`AVG`),
new tokens_1.GroupToken(expression.toTokens()),
]);
exports.avg = avg;
const sum = (expression) => expression_1.makeNamedExpression([
new tokens_1.StringToken(`SUM`),
new tokens_1.GroupToken(expression.toTokens()),
]);
exports.sum = sum;
const not = (condition) => condition_1.makeCondition([new tokens_1.StringToken(`NOT`), new tokens_1.GroupToken(condition.toTokens())]);
exports.not = not;
const and = (condition) => condition_1.makeCondition([new tokens_1.StringToken(`AND`), new tokens_1.GroupToken(condition.toTokens())]);
exports.and = and;
const or = (condition) => condition_1.makeCondition([new tokens_1.StringToken(`OR`), new tokens_1.GroupToken(condition.toTokens())]);
exports.or = or;
const group = (condition) => condition_1.makeCondition([new tokens_1.GroupToken(condition.toTokens())]);
exports.group = group;
exports.min = (expression) => new expression_1.Expression([new tokens_1.StringToken(`MIN`), new tokens_1.GroupToken(expression.toTokens())], 'min');
exports.max = (expression) => new expression_1.Expression([new tokens_1.StringToken(`MAX`), new tokens_1.GroupToken(expression.toTokens())], 'max');
exports.avg = (expression) => new expression_1.Expression([new tokens_1.StringToken(`AVG`), new tokens_1.GroupToken(expression.toTokens())], 'avg');
exports.sum = (expression) => new expression_1.Expression([new tokens_1.StringToken(`SUM`), new tokens_1.GroupToken(expression.toTokens())], 'sum');
exports.xmlagg = (expression) => new expression_1.Expression([new tokens_1.StringToken(`xmlagg`), new tokens_1.GroupToken(expression.toTokens())], 'xmlagg');
exports.not = (condition) => condition_1.makeCondition([new tokens_1.StringToken(`NOT`), new tokens_1.GroupToken(condition.toTokens())]);
exports.and = (condition) => condition_1.makeCondition([new tokens_1.StringToken(`AND`), new tokens_1.GroupToken(condition.toTokens())]);
exports.or = (condition) => condition_1.makeCondition([new tokens_1.StringToken(`OR`), new tokens_1.GroupToken(condition.toTokens())]);
exports.group = (condition) => condition_1.makeCondition([new tokens_1.GroupToken(condition.toTokens())]);
exports.any = (array) => new expression_1.Expression([new tokens_1.StringToken(`ANY`), new tokens_1.GroupToken([new tokens_1.ParameterToken(array)])], '?column?');
exports.now = () => new expression_1.Expression([new tokens_1.StringToken(`NOW()`)], 'now');
exports.exists = (expression) => condition_1.makeCondition([new tokens_1.StringToken(`EXISTS`), new tokens_1.GroupToken(expression.toTokens())]);
exports.notExists = (expression) => condition_1.makeCondition([new tokens_1.StringToken(`NOT EXISTS`), new tokens_1.GroupToken(expression.toTokens())]);
exports.coalesce = (...expressions) => {
return new expression_1.Expression([
new tokens_1.StringToken(`coalesce`),
new tokens_1.GroupToken([
new tokens_1.SeparatorToken(',', expressions.map((expression) => expression instanceof expression_1.Expression
? new tokens_1.CollectionToken(expression.toTokens())
: new tokens_1.ParameterToken(expression))),
]),
], 'coalesce');
};

8

.build/table.d.ts

@@ -7,2 +7,6 @@ import { Column, ColumnDefinition } from './column';

interface InternalTable<TableName, Columns> {
/** @internal */
getName(): string;
/** @internal */
getOriginalName(): string;
as<T>(alias: T): Table<T, {

@@ -14,4 +18,6 @@ [K in keyof Columns]: Columns[K] extends Column<infer Name, string, infer DataType, infer IsNotNull, infer HasDefault, infer JoinType> ? Column<Name, T, DataType, IsNotNull, HasDefault, JoinType> : never;

[column: string]: ColumnDefinition<any, any, any>;
}>(tableName: TableName, originalTableName: string | undefined, tableDefinition: TableDefinition_1) => { [K in keyof TableDefinition_1]: Column<K, TableName, TableDefinition_1[K] extends ColumnDefinition<infer DataType, any, any> ? DataType : never, TableDefinition_1[K] extends ColumnDefinition<any, infer IsNotNull, any> ? IsNotNull : never, TableDefinition_1[K] extends ColumnDefinition<any, any, infer HasDefault> ? HasDefault : never, undefined>; } & {
}>(tableName: TableName, originalTableName: string | undefined, tableDefinition: TableDefinition_1) => { [K in keyof TableDefinition_1]: K extends string ? Column<K, TableName, TableDefinition_1[K] extends ColumnDefinition<infer DataType, any, any> ? DataType : never, TableDefinition_1[K] extends ColumnDefinition<any, infer IsNotNull, any> ? IsNotNull : never, TableDefinition_1[K] extends ColumnDefinition<any, any, infer HasDefault> ? HasDefault : never, undefined> : never; } & {
as<T extends string>(alias: T): any;
getName(): TableName;
getOriginalName(): string | undefined;
};

@@ -18,0 +24,0 @@ export declare const defineTable: <Columns extends {

23

.build/table.js
"use strict";
// type InternalTab<TableDefinitionName> = Nominal<TableDefinitionName>;
Object.defineProperty(exports, "__esModule", { value: true });
exports.defineTable = exports.makeTable = exports.TableDefinition = void 0;
const column_1 = require("./column");
const data_1 = require("./data");
const snake_case_1 = require("./naming/snake-case");

@@ -11,9 +9,6 @@ class TableDefinition {

exports.TableDefinition = TableDefinition;
const makeTable = (tableName, originalTableName, tableDefinition) => {
exports.makeTable = (tableName, originalTableName, tableDefinition) => {
const columnNames = Object.keys(tableDefinition);
const columns = columnNames.reduce((map, columnName) => {
const column = column_1.makeColumn(columnName, tableName, undefined);
data_1.internalColumnData.set(column, {
snakeCaseName: snake_case_1.toSnakeCase(columnName),
});
const column = new column_1.Column(columnName, snake_case_1.wrapQuotes(tableName), undefined);
map[columnName] = column;

@@ -27,13 +22,13 @@ return map;

},
getName() {
return tableName;
},
getOriginalName() {
return originalTableName;
},
};
data_1.internalTableData.set(table, {
name: tableName,
originalName: originalTableName,
});
return table;
};
exports.makeTable = makeTable;
const defineTable = (tableDefinition) => {
exports.defineTable = (tableDefinition) => {
return tableDefinition;
};
exports.defineTable = defineTable;

3

.build/tokens/index.d.ts

@@ -1,10 +0,7 @@

export * from './alias-token';
export * from './collection-token';
export * from './empty-token';
export * from './group-token';
export * from './no-space-token';
export * from './parameter-token';
export * from './raw-token';
export * from './separator-token';
export * from './string-token';
export * from './token';

3

.build/tokens/index.js

@@ -13,11 +13,8 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
__exportStar(require("./alias-token"), exports);
__exportStar(require("./collection-token"), exports);
__exportStar(require("./empty-token"), exports);
__exportStar(require("./group-token"), exports);
__exportStar(require("./no-space-token"), exports);
__exportStar(require("./parameter-token"), exports);
__exportStar(require("./raw-token"), exports);
__exportStar(require("./separator-token"), exports);
__exportStar(require("./string-token"), exports);
__exportStar(require("./token"), exports);

3

.build/tokens/token.js

@@ -7,3 +7,3 @@ "use strict";

exports.Token = Token;
const createQueryState = (tokens, currentParameterIndex = 0) => {
exports.createQueryState = (tokens, currentParameterIndex = 0) => {
const initialState = {

@@ -15,2 +15,1 @@ text: [],

};
exports.createQueryState = createQueryState;

2

.build/types.d.ts

@@ -8,3 +8,3 @@ export declare type ResultType = 'ROWS' | 'AFFECTED_COUNT';

};
export declare class GetDataType<Type, IsNull> {
export declare class GetDataType<Type, IsNull extends boolean> {
private _;

@@ -11,0 +11,0 @@ }

7

.build/update.d.ts

@@ -11,2 +11,3 @@ import { Token } from './tokens';

private readonly queryExecutor;
private readonly returningKeys;
private readonly table;

@@ -16,3 +17,5 @@ private readonly resultType;

private _updateQueryBrand;
constructor(queryExecutor: QueryExecutorFn, table: T, resultType: ResultType, tokens: Token[]);
/** @internal */
getReturningKeys(): string[];
constructor(queryExecutor: QueryExecutorFn, returningKeys: string[], table: T, resultType: ResultType, tokens: Token[]);
then(onFulfilled?: ((value: Returning extends number ? Returning : ResultSet<UpdateQuery<T, Returning>, false>[]) => any | PromiseLike<any>) | undefined | null, onRejected?: ((reason: any) => void | PromiseLike<void>) | undefined | null): Promise<any>;

@@ -36,3 +39,3 @@ where(condition: Condition): UpdateQuery<T, Returning>;

export declare const makeUpdate: (queryExecutor: QueryExecutorFn) => <T extends unknown>(table: T) => {
set(values: T extends Table<any, infer Columns> ? { [K in keyof Columns]?: (Columns[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? DataType | Expression<DataType, boolean> : DataType | Expression<DataType | undefined, boolean> | undefined : never) | undefined; } : never): UpdateQuery<T, number, T extends Table<any, infer Columns_1> ? Columns_1 : never>;
set(values: T extends Table<any, infer Columns> ? { [K in keyof Columns]?: (Columns[K] extends Column<any, any, infer DataType, infer IsNotNull, any, any> ? IsNotNull extends true ? DataType | Expression<DataType, boolean, any> : DataType | Expression<DataType | undefined, boolean, any> | undefined : never) | undefined; } : never): UpdateQuery<T, number, T extends Table<any, infer Columns_1> ? Columns_1 : never>;
};

43

.build/update.js

@@ -5,9 +5,9 @@ "use strict";

const tokens_1 = require("./tokens");
const data_1 = require("./data");
const query_1 = require("./query");
// https://www.postgresql.org/docs/12/sql-update.html
class UpdateQuery extends query_1.Query {
constructor(queryExecutor, table, resultType, tokens) {
constructor(queryExecutor, returningKeys, table, resultType, tokens) {
super();
this.queryExecutor = queryExecutor;
this.returningKeys = returningKeys;
this.table = table;

@@ -17,2 +17,6 @@ this.resultType = resultType;

}
/** @internal */
getReturningKeys() {
return this.returningKeys;
}
then(onFulfilled, onRejected) {

@@ -27,3 +31,3 @@ const queryState = tokens_1.createQueryState(this.tokens);

where(condition) {
return new UpdateQuery(this.queryExecutor, this.table, this.resultType, [
return new UpdateQuery(this.queryExecutor, this.returningKeys, this.table, this.resultType, [
...this.tokens,

@@ -35,3 +39,3 @@ new tokens_1.StringToken(`WHERE`),

whereCurrentOf(cursorName) {
return new UpdateQuery(this.queryExecutor, this.table, this.resultType, [
return new UpdateQuery(this.queryExecutor, this.returningKeys, this.table, this.resultType, [
...this.tokens,

@@ -43,20 +47,19 @@ new tokens_1.StringToken(`WHERE CURRENT OF`),

from(fromItem) {
const tableData = data_1.getTableData(fromItem);
return new UpdateQuery(this.queryExecutor, this.table, this.resultType, [
return new UpdateQuery(this.queryExecutor, this.returningKeys, this.table, this.resultType, [
...this.tokens,
new tokens_1.StringToken(`FROM`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(fromItem.getName()),
]);
}
returning(...columns) {
return new UpdateQuery(this.queryExecutor, this.table, 'ROWS', [
returning(...columnNames) {
return new UpdateQuery(this.queryExecutor, columnNames, this.table, 'ROWS', [
...this.tokens,
new tokens_1.StringToken(`RETURNING`),
new tokens_1.SeparatorToken(`,`, columns.map((alias) => {
const columnData = data_1.getColumnData(this.table[alias]);
if (alias !== columnData.snakeCaseName) {
return new tokens_1.StringToken(`${columnData.snakeCaseName} "${alias}"`);
new tokens_1.SeparatorToken(`,`, columnNames.map((alias) => {
const column = this.table[alias];
if (alias !== column.getSnakeCaseName()) {
return new tokens_1.StringToken(`${column.getSnakeCaseName()} "${alias}"`);
}
else {
return new tokens_1.StringToken(columnData.snakeCaseName);
return new tokens_1.StringToken(column.getSnakeCaseName());
}

@@ -72,17 +75,16 @@ })),

exports.UpdateQuery = UpdateQuery;
const makeUpdate = (queryExecutor) => (table) => {
exports.makeUpdate = (queryExecutor) => (table) => {
//
return {
set(values) {
const tableData = data_1.getTableData(table);
const keys = Object.keys(values);
return new UpdateQuery(queryExecutor, table, 'AFFECTED_COUNT', [
return new UpdateQuery(queryExecutor, [], table, 'AFFECTED_COUNT', [
new tokens_1.StringToken(`UPDATE`),
new tokens_1.StringToken(tableData.name),
new tokens_1.StringToken(table.getName()),
new tokens_1.StringToken(`SET`),
new tokens_1.SeparatorToken(`,`, keys.map((key) => {
const columnData = data_1.getColumnData(table[key]);
const column = table[key];
const value = values[key];
return new tokens_1.CollectionToken([
new tokens_1.StringToken(columnData.snakeCaseName),
new tokens_1.StringToken(column.getSnakeCaseName()),
new tokens_1.StringToken(`=`),

@@ -98,2 +100,1 @@ value && typeof value === `object` && 'toTokens' in value

};
exports.makeUpdate = makeUpdate;

2

package.json
{
"name": "@ff00ff/mammoth",
"license": "MIT",
"version": "1.0.0-rc.5",
"version": "1.0.0-rc.6",
"main": "./.build/index.js",

@@ -6,0 +6,0 @@ "types": "./.build/index.d.ts",

119

README.md

@@ -10,3 +10,3 @@ ![Mammoth](https://s3-eu-west-1.amazonaws.com/mammoth-static.ff00ff.nl/mammoth-logo.png)

```
npm i @ff00ff/mammoth@1.0.0-rc.4
npm i @ff00ff/mammoth@1.0.0-rc.6
```

@@ -20,7 +20,7 @@

const rows = await db
.select(foo.id, bar.name)
.from(foo)
.leftJoin(bar)
.on(foo.barId.eq(bar.id))
.where(foo.id.eq(`1`));
.select(db.foo.id, db.bar.name)
.from(db.foo)
.leftJoin(db.bar)
.on(db.foo.barId.eq(db.bar.id))
.where(db.foo.id.eq(`1`));
```

@@ -48,3 +48,3 @@

```ts
const updateCount = await db.update(foo).set({ name: `Test` }).where(foo.value.gt(0));
const updateCount = await db.update(db.foo).set({ name: `Test` }).where(db.foo.value.gt(0));
```

@@ -67,3 +67,3 @@

const rows = await db
.insertInto(foo)
.insertInto(db.foo)
.values({

@@ -95,10 +95,86 @@ name: `Test`,

const affectedCount = await db
.insertInto(foo, ['name'])
.select(bar.name)
.from(bar)
.where(bar.name.isNotNull());
.insertInto(db.foo, ['name'])
.select(db.bar.name)
.from(db.bar)
.where(db.bar.name.isNotNull());
```
```sql
INSERT INTO foo (name)
SELECT
bar.name
FROM bar
WHERE
bar.name IS NOT NULL
```
</details>
<details>
<summary>Select with count(*)</summary>
```ts
db.select(count()).from(db.foo);
```
```sql
SELECT COUNT(*) FROM foo
```
</details>
<details>
<summary>Select with aggregate expression</summary>
```ts
db.select(arrayAgg(db.foo.name.orderBy(db.foo.name.desc()))).from(db.foo);
```
```sql
SELECT array_agg(foo.name ORDER BY foo.name DESC) "arrayAgg" FROM foo
```
</details>
<details>
<summary>With (CTE) query</summary>
```ts
db.with(
`regionalSales`,
() =>
db
.select(db.orderLog.region, sum(db.orderLog.amount).as(`totalSales`))
.from(db.orderLog)
.groupBy(db.orderLog.region),
`topRegions`,
({ regionalSales }) =>
db
.select(regionalSales.region)
.from(regionalSales)
.where(
regionalSales.totalSales.gt(
db.select(sum(regionalSales.totalSales).divide(10)).from(regionalSales),
),
),
({ topRegions }) =>
db
.select(
db.orderLog.region,
db.orderLog.product,
sum(db.orderLog.quantity).as(`productUnits`),
sum(db.orderLog.amount).as(`productSales`),
)
.from(db.orderLog)
.where(db.orderLog.region.in(db.select(topRegions.region).from(topRegions)))
.groupBy(db.orderLog.region, db.orderLog.product),
);
```
```sql
WITH "regionalSales" AS (SELECT order_log.region, SUM (order_log.amount) "totalSales" FROM order_log GROUP BY order_log.region), "topRegions" AS (SELECT "regionalSales".region FROM "regionalSales" WHERE "regionalSales"."totalSales" > (SELECT SUM ("regionalSales"."totalSales") / $1 FROM "regionalSales")) SELECT order_log.region, order_log.product, SUM (order_log.quantity) "productUnits", SUM (order_log.amount) "productSales" FROM order_log WHERE order_log.region IN (SELECT "topRegions".region FROM "topRegions") GROUP BY order_log.region, order_log.product
```
</details>
---

@@ -114,8 +190,9 @@

import { defineDb } from '@ff00ff/mammoth';
import { foo, bar } from './tables';
const db = defineDb(async (query, parameters) => {
const db = defineDb({ foo, bar }, async (query, parameters) => {
const result = await pool.query(query, parameters);
return {
affectedRowCount: result.rowCount,
affectedCount: result.rowCount,
rows: result.rows,

@@ -126,7 +203,7 @@ };

You have to define all the tables to make sure Mammoth understands the type information. This should be close to the CREATE TABLE syntax.
In the `defineDb` call you pass all your tables so they can be access through the db instance. You have to define all the tables to make sure Mammoth understands the type information. This should be close to the CREATE TABLE syntax.
```ts
const foo = defineTable(`foo`, {
id: uuid().primaryKey().default(`gen_random_id()`),
const foo = defineTable({
id: uuid().primaryKey().default(`gen_random_uuid()`),
createDate: timestampWithTimeZone().notNull().default(`now()`),

@@ -147,3 +224,3 @@ name: text().notNull(),

- [ WITH [ RECURSIVE ] with_query [, ...] ] — Not supported yet
- [ WITH [ RECURSIVE ] with_query [, ...] ] — Partial support. Recursive not supported yet.
- SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ] — Mostly supported. Distinct not yet.

@@ -168,3 +245,3 @@ - [ \* | expression [ [ AS ] output_name ] [, ...] ] — mostly supported. Selecting certain expressions like update queries, insert and delete queries are not supported yet. Select queries are though.

- [ WITH [ RECURSIVE ] with_query [, ...] ] — not supported yet.
- [ WITH [ RECURSIVE ] with_query [, ...] ] — Partial support. Recursive not supported yet.
- UPDATE [ ONLY ] table_name [ * ] [ [ AS ] alias ] — supported

@@ -184,3 +261,3 @@ - SET { column_name = { expression | DEFAULT } | — supported, but expression concept is very broad and might be incomplete

- [ WITH [ RECURSIVE ] with_query [, ...] ] — not supported yet
- [ WITH [ RECURSIVE ] with_query [, ...] ] — Partial support. Recursive not supported yet.
- DELETE FROM [ ONLY ] table_name [ * ] [ [ AS ] alias ] — supported

@@ -195,3 +272,3 @@ - [ USING from_item [, ...] ] — supported

- [ WITH [ RECURSIVE ] with_query [, ...] ] — not supported
- [ WITH [ RECURSIVE ] with_query [, ...] ] — Partial support. Recursive not supported yet.
- INSERT INTO table_name [ AS alias ] [ ( column_name [, ...] ) ] — supported

@@ -198,0 +275,0 @@ - [ OVERRIDING { SYSTEM | USER } VALUE ] — not supported

.build/data.d.ts
.build/data.js
.build/tokens/alias-token.d.ts
.build/tokens/alias-token.js
.build/tokens/no-space-token.d.ts
.build/tokens/no-space-token.js
.build/tokens/raw-token.d.ts
.build/tokens/raw-token.js
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc