prefix
stringlengths 82
32.6k
| middle
stringlengths 5
470
| suffix
stringlengths 0
81.2k
| file_path
stringlengths 6
168
| repo_name
stringlengths 16
77
| context
listlengths 5
5
| lang
stringclasses 4
values | ground_truth
stringlengths 5
470
|
|---|---|---|---|---|---|---|---|
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import { ignore } from './utils/test-utils';
import { SelectionColumn } from '../lib/type-utils';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('table mapper setting type checks', () => {
ignore('detects invalid return columns configurations', () => {
new TableMapper<Database, 'users', ['id']>(db, 'users', {
// @ts-expect-error - invalid return column configuration
insertReturnColumns: ['notThere'],
// @ts-expect-error - invalid return column configuration
updateReturnColumns: ['notThere'],
});
new TableMapper<Database, 'users', ['id']>(db, 'users', {
// @ts-expect-error - actual and declared return types must match
insertReturnColumns: ['id', 'name'],
// @ts-expect-error - actual and declared return types must match
updateReturnColumns: ['id', 'name'],
});
new TableMapper<
Database,
'users',
[],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
bigint,
// @ts-expect-error - invalid return column configuration
['notThere']
>(db, 'users', {});
new TableMapper<
Database,
'users',
[],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
bigint,
['name'],
// @ts-expect-error - invalid return column configuration
['name', 'notThere']
>(db, 'users', {});
new TableMapper<Database, 'users', ['id']>(db, 'users', {
// @ts-expect-error - invalid return column configuration
insertReturnColumns: [''],
// @ts-expect-error - invalid return column configuration
updateReturnColumns: [''],
});
new TableMapper<Database, 'users', ['id']>(db, 'users', {
// @ts-expect-error - invalid return column configuration
insertReturnColumns: ['notThere'],
// @ts-expect-error - invalid return column configuration
updateReturnColumns: ['notThere'],
});
class TestMapper6<
InsertReturnColumns extends
| SelectionColumn<Database, 'users'>[]
| ['*'] = [],
UpdateReturnColumns extends
| SelectionColumn<Database, 'users'>[]
| ['*'] = []
> extends TableMapper<
Database,
'users',
[],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
number,
InsertReturnColumns,
UpdateReturnColumns
> {}
new
|
TestMapper6(db, 'users', {
|
// @ts-expect-error - invalid return column configuration
insertReturnColumns: ['notThere'],
// @ts-expect-error - invalid return column configuration
updateReturnColumns: ['notThere'],
});
new TableMapper<
Database,
'users',
[],
any,
any,
any,
any,
number,
['id', 'name']
>(db, 'users', {
// @ts-expect-error - actual and declared return types must match
insertReturnColumns: ['id'],
// @ts-expect-error - actual and declared return types must match
updateReturnColumns: ['id'],
});
new TableMapper<
Database,
'users',
[],
any,
any,
any,
any,
number,
['*'],
['*']
>(db, 'users', {
// @ts-expect-error - actual and declared return types must match
insertReturnColumns: ['id'],
// @ts-expect-error - actual and declared return types must match
updateReturnColumns: ['id'],
});
new TableMapper<Database, 'users', [], any, any, any, any, number, [], []>(
db,
'users',
{
// @ts-expect-error - actual and declared return types must match
insertReturnColumns: ['id'],
// @ts-expect-error - actual and declared return types must match
updateReturnColumns: ['id'],
}
);
});
ignore('detects invalid return count configuration', () => {
class TestMapper extends TableMapper<
Database,
'users',
['id'],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
number
> {}
new TestMapper(db, 'users', {
// @ts-expect-error - invalid return count
countTransform: (count: bigint) => BigInt(count),
});
});
it('accepts readonly KeyColumns', () => {
new TableMapper<
Database,
'users',
Readonly<['id']> // should not error
>(db, 'users', {});
});
it('accepts readonly SelectedColumns', () => {
new TableMapper<
Database,
'users',
['id'],
Readonly<['id', 'name']> // should not error
>(db, 'users', {});
});
it('accepts readonly return columns', () => {
new TableMapper<
Database,
'users',
['id'],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
bigint,
Readonly<['id']>, // should not error
Readonly<['name']> // should not error
>(db, 'users', {});
});
it('accepts readonly settings', () => {
const settings = {
insertReturnColumns: ['id'] as const,
updateReturnColumns: ['name'] as const,
} as const;
new TableMapper(db, 'users', settings);
});
});
|
src/tests/setting-types.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " ) {}\n }\n const keyColumns = ['id'] as const;\n const userMapper = new TableMapper(db, 'users', {\n keyColumns,\n updateReturnColumns: ['id', 'name'],\n }).withTransforms(new EntireRowTransforms(keyColumns));\n // test updating a non-existent user\n const userWithID = new MappedUser(\n 1,",
"score": 0.8679617047309875
},
{
"filename": "src/tests/utils/test-mappers.ts",
"retrieved_chunk": " return new TableMapper(db, 'users', {\n insertReturnColumns: ['*'],\n updateReturnColumns: ['*'],\n }).withTransforms({\n countTransform,\n });\n}\nexport function createInsertTransformMapper(db: Kysely<Database>) {\n return new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],",
"score": 0.8605782985687256
},
{
"filename": "src/tests/utils/test-mappers.ts",
"retrieved_chunk": " return new TableMapper(db, 'users', {\n keyColumns: noColumns,\n updateReturnColumns: noColumns,\n }).withTransforms({\n countTransform,\n });\n}\nexport function createUserMapperReturningID(db: Kysely<Database>) {\n return new TableMapper(db, 'users', {\n keyColumns: ['id'],",
"score": 0.8501005172729492
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " 'handle',\n 'email',\n ];\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },",
"score": 0.8483107089996338
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " // Ensure that columns can be addressed by name.\n ((_: number) => {})(users[0].id);\n ((_: string) => {})(users[0].handle);\n ((_: string) => {})(users[0].name);\n ((_: string) => {})(users[0].email!);\n const user = await userMapper\n .select()\n .modify((qb) => qb.select('name').orderBy('handle', 'desc'))\n .returnOne();\n expect(user).toEqual({ ...USERS[2], id: 3 });",
"score": 0.8449233770370483
}
] |
typescript
|
TestMapper6(db, 'users', {
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningIDAndHandleAsH,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { User } from './utils/test-types';
let db: Kysely<Database>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningIDAndHandleAsH: ReturnType<
typeof createUserMapperReturningIDAndHandleAsH
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningIDAndHandleAsH =
createUserMapperReturningIDAndHandleAsH(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('compiled updates', () => {
it('updates nothing returning zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const compilation = userMapperReturningID
.update({ id: 1 })
.columns(['email'])
.compile();
const success2 = await compilation.run({}, updateValues);
expect(success2).toBe(false);
const updateCount2 = await compilation.returnCount({}, updateValues);
expect(updateCount2).toEqual(0);
const updates2 = await compilation.returnAll({}, updateValues);
expect(updates2.length).toEqual(0);
const update2 = await compilation.returnOne({}, updateValues);
expect(update2).toBeNull();
});
it('compilations accept readonly updating objects', async () => {
const compilation = userMapperReturningNothing
.update('id', '=', 1)
.columns(['name', 'email'])
.compile();
const updateValues1 = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
await compilation.run({}, updateValues1);
});
it('compiles a non-returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningNothing
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = {
name: 'Johnny Rex' as const,
email: 'jrex@abc.def' as const,
} as const;
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2).toBeUndefined();
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3).toBeUndefined();
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
});
it('compiles a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningIDAndHandleAsH
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = { name: 'Sue Rex', email: 'srex@abc.def' };
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex', email: 'jrex@abc.def' };
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2?.id).toEqual(insertReturns[0].id);
expect(updateReturns2?.h).toEqual(USERS[0].handle);
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3[0].id).toEqual(insertReturns[0].id);
expect(updateReturns3[0].h).toEqual(USERS[0].handle);
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
ignore('check compile-time types', () => {
compilation.returnOne(
{},
{
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
// @ts-expect-error - only insertable columns are allowed
notThere: 32,
}
);
// @ts-expect-error - only expected columns are returned
updateReturns2!.handle;
// @ts-expect-error - only expected columns are returned
updateReturns3[0].handle;
});
});
it('accepts readonly parameters and updating objects', async () => {
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
const params = { id: 1 as const } as const;
const updateValues = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
await parameterization.run(params, updateValues);
await parameterization.returnAll(params, updateValues);
await parameterization.returnOne(params, updateValues);
await parameterization.returnCount(params, updateValues);
});
it('parameterizes a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test run()
const updateValues1 = { name: 'Sue Rex' };
const updateReturns1 = await parameterization.run(
{ id: insertReturns[0].id },
updateValues1
);
expect(updateReturns1).toBe(true);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex' };
const updateReturns2 = await parameterization.returnOne(
{ id: insertReturns[1].id },
updateValues2
);
expect(updateReturns2?.id).toEqual(insertReturns[1].id);
expect(updateReturns2?.h).toEqual(USERS[1].handle);
// test returnAll()
const updateReturns3 = await parameterization.returnAll(
{ id: insertReturns[2].id },
updateValues1
);
expect(updateReturns3[0].id).toEqual(insertReturns[2].id);
expect(updateReturns3[0].h).toEqual(USERS[2].handle);
// verify updates
const readUsers = await userMapperReturningID.select().returnAll();
expect(readUsers[0].name).toEqual(updateValues1.name);
expect(readUsers[1].name).toEqual(updateValues2.name);
expect(readUsers[2].name).toEqual(updateValues1.name);
// test returnCount()
const updateReturns4 = await parameterization.returnCount(
{ id: insertReturns[0].id },
updateValues2
);
expect(updateReturns4).toEqual(1);
const readUser = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser?.name).toEqual(updateValues2.name);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid column names
updateReturns2!.handle;
// @ts-expect-error - errors on invalid column names
updateReturns3[0].handle;
userMapperReturningIDAndHandleAsH.parameterize<{ id: number }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
userMapperReturningIDAndHandleAsH.parameterize<{ id: string }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, updateValues1);
parameterization.returnOne(
{ id: 1 },
{
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
// @ts-expect-error - only updateable columns are allowed
notThere: 32,
}
);
});
});
it('compiles an update query with transformation', async () => {
expect.assertions(12);
const columnSubset: (keyof Updateable
|
<Users>)[] = ['name'];
|
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['*'],
updateReturnColumns: ['*'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
insertReturnTransform: (_source, returns) => {
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
updateTransform: (source: User, columns) => {
expect(columns).toEqual(columnSubset);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (_source, returns) => {
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');
const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const compilation = transformMapper
.update({ id: insertReturns[2].id })
.columns(columnSubset)
.compile();
// test returnOne()
const updateReturn1 = await compilation.returnOne({}, user1);
const expectedUser1 = User.create(insertReturns[2].id, {
firstName: user1.firstName,
lastName: user1.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn1).toEqual(expectedUser1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
const readUser1 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser1).toEqual(expectedUser1);
// test returnAll()
const updateReturn2 = await compilation.returnAll({}, user2);
const expectedUser2 = User.create(insertReturns[2].id, {
firstName: user2.firstName,
lastName: user2.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn2[0]).toEqual(expectedUser2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
const readUser2 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser2).toEqual(expectedUser2);
// test run()
const success1 = await compilation.run({}, user1);
expect(success1).toBe(true);
const readUser3 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser3).toEqual(expectedUser1);
// test returnCount()
const count = await compilation.returnCount({}, user2);
expect(count).toEqual(1);
const readUser4 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser4).toEqual(expectedUser2);
ignore('check compile-time types', async () => {
// @ts-expect-error - only update objects are allowed
compilation.returnOne({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnAll({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnCount({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.run({}, USERS[0]);
// @ts-expect-error - correct return is expected
(await compilation.returnOne({}, user1))!.name;
// @ts-expect-error - correct return is expected
(await compilation.returnAll({}, user2))[0].name;
});
});
it('parameterizes an update query with transformation', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
insertReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
updateTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
updateReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');
const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const parameterization = transformMapper.parameterize<{ id: number }>(
({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test returnOne()
const updateReturn1 = await parameterization.returnOne(
{ id: insertReturns[0].id },
user2
);
const expectedReturn1 = {
id: insertReturns[0].id,
firstName: user2.firstName,
lastName: user2.lastName,
};
expect(updateReturn1).toEqual(expectedReturn1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
// test returnAll()
const updateReturn2 = await parameterization.returnAll(
{ id: insertReturns[1].id },
user3
);
const expectedReturn2 = {
id: insertReturns[1].id,
firstName: user3.firstName,
lastName: user3.lastName,
};
expect(updateReturn2[0]).toEqual(expectedReturn2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
// test run()
const success1 = await parameterization.run(
{ id: insertReturns[2].id },
user1
);
const expectedReturn3 = {
id: insertReturns[2].id,
firstName: user1.firstName,
lastName: user1.lastName,
};
expect(success1).toBe(true);
// verify updates
const readUsers = await transformMapper.select().returnAll();
expect(readUsers).toEqual([
User.create(expectedReturn1.id, {
...expectedReturn1,
handle: user1.handle,
email: user1.email!,
}),
User.create(expectedReturn2.id, {
...expectedReturn2,
handle: user2.handle,
email: user2.email!,
}),
User.create(expectedReturn3.id, {
...expectedReturn3,
handle: user3.handle,
email: user3.email!,
}),
]);
// test returnCount()
const count = await parameterization.returnCount(
{ id: insertReturns[2].id },
user2
);
expect(count).toEqual(1);
const readUser = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser).toEqual(
User.create(insertReturns[2].id, {
...expectedReturn1,
handle: user3.handle,
email: user3.email!,
})
);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid column names
updateReturn1!.handle;
// @ts-expect-error - errors on invalid column names
updateReturn2[0].handle;
transformMapper.parameterize<{ id: number }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
transformMapper.parameterize<{ id: string }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, user1);
parameterization.returnOne(
{ id: 1 },
{
// @ts-expect-error - only updateable columns are allowed
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
}
);
});
});
it('requires all indicated columns to be updated', async () => {
await userMapperReturningID.insert().run(USERS);
const compilation = userMapperReturningID
.update()
.columns(['name', 'handle', 'email'])
.compile();
const updateValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => compilation.returnOne({}, updateValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await compilation.run({}, { ...updateValues, email: null });
expect(success).toBe(true);
});
});
|
src/tests/update-compile.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " notThere: 32,\n });\n // @ts-expect-error - only expected columns are returned\n insertReturn!.notThere;\n });\n });\n it('compiles an insert query with transformation', async () => {\n expect.assertions(7);\n const columnSubset: (keyof Insertable<Users>)[] = [\n 'name',",
"score": 0.9264963269233704
},
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " const success = await subsetQuery.run({ ...updateValues, email: null });\n expect(success).toBe(true);\n });\n it('provides updateTransform with column subset', async () => {\n expect.assertions(1);\n const mapper = new TableMapper(db, 'users').withTransforms({\n updateTransform: (source, columns) => {\n expect(columns).toEqual(['name', 'handle']);\n return source;\n },",
"score": 0.8809300661087036
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - errors on invalid column names\n users[0].notThere;\n // @ts-expect-error - errors on invalid column names\n user!.notThere;\n });\n });\n it('parameterizes and compiles a select query', async () => {\n await userMapper.insert().run(USERS);\n const parameterization = userMapper.parameterize<{ name: string }>(\n ({ mapper, param }) => mapper.select({ name: param('name') })",
"score": 0.8623083829879761
},
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " });\n it('requires all subsetted columns to be updated', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const updateValues = { name: 'Sue Rex' };\n const subsetQuery = userMapperReturningID\n .update('id', '=', insertReturns[0].id)\n .columns(['name', 'email']);\n expect(() => subsetQuery.returnAll(updateValues)).rejects.toThrow(\n `column 'email' missing`\n );",
"score": 0.860923171043396
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " expect(updateReturn2).toEqual(1);\n // Ensure the returned value is accessible as a number\n ((_: number) => {})(updateReturn2!);\n });\n it(\"transforms update and update return, columns is ['*']\", async () => {\n expect.assertions(2);\n const updateAndReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({",
"score": 0.8581768274307251
}
] |
typescript
|
<Users>)[] = ['name'];
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningIDAndHandleAsH,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { User } from './utils/test-types';
let db: Kysely<Database>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningIDAndHandleAsH: ReturnType<
typeof createUserMapperReturningIDAndHandleAsH
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningIDAndHandleAsH =
createUserMapperReturningIDAndHandleAsH(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('compiled updates', () => {
it('updates nothing returning zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const compilation = userMapperReturningID
.update({ id: 1 })
.columns(['email'])
.compile();
const success2 = await compilation.run({}, updateValues);
expect(success2).toBe(false);
const updateCount2 = await compilation.returnCount({}, updateValues);
expect(updateCount2).toEqual(0);
const updates2 = await compilation.returnAll({}, updateValues);
expect(updates2.length).toEqual(0);
const update2 = await compilation.returnOne({}, updateValues);
expect(update2).toBeNull();
});
it('compilations accept readonly updating objects', async () => {
const compilation = userMapperReturningNothing
.update('id', '=', 1)
.columns(['name', 'email'])
.compile();
const updateValues1 = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
await compilation.run({}, updateValues1);
});
it('compiles a non-returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningNothing
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = {
name: 'Johnny Rex' as const,
email: 'jrex@abc.def' as const,
} as const;
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2).toBeUndefined();
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3).toBeUndefined();
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
});
it('compiles a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningIDAndHandleAsH
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = { name: 'Sue Rex', email: 'srex@abc.def' };
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex', email: 'jrex@abc.def' };
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2?.id).toEqual(insertReturns[0].id);
expect(updateReturns2?.h).toEqual(USERS[0].handle);
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3[0].id).toEqual(insertReturns[0].id);
expect(updateReturns3[0].h).toEqual(USERS[0].handle);
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
ignore('check compile-time types', () => {
compilation.returnOne(
{},
{
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
// @ts-expect-error - only insertable columns are allowed
notThere: 32,
}
);
// @ts-expect-error - only expected columns are returned
updateReturns2!.handle;
// @ts-expect-error - only expected columns are returned
updateReturns3[0].handle;
});
});
it('accepts readonly parameters and updating objects', async () => {
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
const params = { id: 1 as const } as const;
const updateValues = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
await parameterization.run(params, updateValues);
await parameterization.returnAll(params, updateValues);
await parameterization.returnOne(params, updateValues);
await parameterization.returnCount(params, updateValues);
});
it('parameterizes a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test run()
const updateValues1 = { name: 'Sue Rex' };
const updateReturns1 = await parameterization.run(
{ id: insertReturns[0].id },
updateValues1
);
expect(updateReturns1).toBe(true);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex' };
const updateReturns2 = await parameterization.returnOne(
{ id: insertReturns[1].id },
updateValues2
);
expect(updateReturns2?.id).toEqual(insertReturns[1].id);
expect(updateReturns2?.h).toEqual(USERS[1].handle);
// test returnAll()
const updateReturns3 = await parameterization.returnAll(
{ id: insertReturns[2].id },
updateValues1
);
expect(updateReturns3[0].id).toEqual(insertReturns[2].id);
expect(updateReturns3[0].h).toEqual(USERS[2].handle);
// verify updates
const readUsers = await userMapperReturningID.select().returnAll();
expect(readUsers[0].name).toEqual(updateValues1.name);
expect(readUsers[1].name).toEqual(updateValues2.name);
expect(readUsers[2].name).toEqual(updateValues1.name);
// test returnCount()
const updateReturns4 = await parameterization.returnCount(
{ id: insertReturns[0].id },
updateValues2
);
expect(updateReturns4).toEqual(1);
const readUser = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser?.name).toEqual(updateValues2.name);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid column names
updateReturns2!.handle;
// @ts-expect-error - errors on invalid column names
updateReturns3[0].handle;
userMapperReturningIDAndHandleAsH.parameterize<{ id: number }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
userMapperReturningIDAndHandleAsH.parameterize<{ id: string }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, updateValues1);
parameterization.returnOne(
{ id: 1 },
{
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
// @ts-expect-error - only updateable columns are allowed
notThere: 32,
}
);
});
});
it('compiles an update query with transformation', async () => {
expect.assertions(12);
const columnSubset: (keyof Updateable<Users>)[] = ['name'];
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['*'],
updateReturnColumns: ['*'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
|
insertReturnTransform: (_source, returns) => {
|
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
updateTransform: (source: User, columns) => {
expect(columns).toEqual(columnSubset);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (_source, returns) => {
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');
const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const compilation = transformMapper
.update({ id: insertReturns[2].id })
.columns(columnSubset)
.compile();
// test returnOne()
const updateReturn1 = await compilation.returnOne({}, user1);
const expectedUser1 = User.create(insertReturns[2].id, {
firstName: user1.firstName,
lastName: user1.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn1).toEqual(expectedUser1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
const readUser1 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser1).toEqual(expectedUser1);
// test returnAll()
const updateReturn2 = await compilation.returnAll({}, user2);
const expectedUser2 = User.create(insertReturns[2].id, {
firstName: user2.firstName,
lastName: user2.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn2[0]).toEqual(expectedUser2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
const readUser2 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser2).toEqual(expectedUser2);
// test run()
const success1 = await compilation.run({}, user1);
expect(success1).toBe(true);
const readUser3 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser3).toEqual(expectedUser1);
// test returnCount()
const count = await compilation.returnCount({}, user2);
expect(count).toEqual(1);
const readUser4 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser4).toEqual(expectedUser2);
ignore('check compile-time types', async () => {
// @ts-expect-error - only update objects are allowed
compilation.returnOne({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnAll({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnCount({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.run({}, USERS[0]);
// @ts-expect-error - correct return is expected
(await compilation.returnOne({}, user1))!.name;
// @ts-expect-error - correct return is expected
(await compilation.returnAll({}, user2))[0].name;
});
});
it('parameterizes an update query with transformation', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
insertReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
updateTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
updateReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');
const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const parameterization = transformMapper.parameterize<{ id: number }>(
({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test returnOne()
const updateReturn1 = await parameterization.returnOne(
{ id: insertReturns[0].id },
user2
);
const expectedReturn1 = {
id: insertReturns[0].id,
firstName: user2.firstName,
lastName: user2.lastName,
};
expect(updateReturn1).toEqual(expectedReturn1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
// test returnAll()
const updateReturn2 = await parameterization.returnAll(
{ id: insertReturns[1].id },
user3
);
const expectedReturn2 = {
id: insertReturns[1].id,
firstName: user3.firstName,
lastName: user3.lastName,
};
expect(updateReturn2[0]).toEqual(expectedReturn2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
// test run()
const success1 = await parameterization.run(
{ id: insertReturns[2].id },
user1
);
const expectedReturn3 = {
id: insertReturns[2].id,
firstName: user1.firstName,
lastName: user1.lastName,
};
expect(success1).toBe(true);
// verify updates
const readUsers = await transformMapper.select().returnAll();
expect(readUsers).toEqual([
User.create(expectedReturn1.id, {
...expectedReturn1,
handle: user1.handle,
email: user1.email!,
}),
User.create(expectedReturn2.id, {
...expectedReturn2,
handle: user2.handle,
email: user2.email!,
}),
User.create(expectedReturn3.id, {
...expectedReturn3,
handle: user3.handle,
email: user3.email!,
}),
]);
// test returnCount()
const count = await parameterization.returnCount(
{ id: insertReturns[2].id },
user2
);
expect(count).toEqual(1);
const readUser = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser).toEqual(
User.create(insertReturns[2].id, {
...expectedReturn1,
handle: user3.handle,
email: user3.email!,
})
);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid column names
updateReturn1!.handle;
// @ts-expect-error - errors on invalid column names
updateReturn2[0].handle;
transformMapper.parameterize<{ id: number }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
transformMapper.parameterize<{ id: string }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, user1);
parameterization.returnOne(
{ id: 1 },
{
// @ts-expect-error - only updateable columns are allowed
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
}
);
});
});
it('requires all indicated columns to be updated', async () => {
await userMapperReturningID.insert().run(USERS);
const compilation = userMapperReturningID
.update()
.columns(['name', 'handle', 'email'])
.compile();
const updateValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => compilation.returnOne({}, updateValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await compilation.run({}, { ...updateValues, email: null });
expect(success).toBe(true);
});
});
|
src/tests/update-compile.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " handle: source.handle,\n email: source.email,\n };\n }\n return source;\n },\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return SelectedUser.create(row.id, {\n firstName: names[0],",
"score": 0.9316398501396179
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(columns).toEqual(['*']);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n insertReturnTransform: (source: InsertedUser, returns) =>\n new ReturnedUser(\n returns.id,",
"score": 0.9239009618759155
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " insertTransform: (source: User, columns) => {\n expect(columns).toEqual(columnSubset);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n insertReturnTransform: (source: User, returns) =>\n new User(",
"score": 0.921715259552002
},
{
"filename": "src/tests/utils/test-mappers.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n countTransform: (count) => Number(count),\n });\n}",
"score": 0.9183236360549927
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " 'handle',\n 'email',\n ];\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },",
"score": 0.910142183303833
}
] |
typescript
|
insertReturnTransform: (_source, returns) => {
|
import { Insertable } from 'kysely';
import { Users, Posts } from './test-tables';
import { InsertedUser, ReturnedUser, SelectedUser } from './test-types';
export const USERS: Insertable<Users>[] = [
{
handle: 'handle1',
name: 'Sue',
email: 'foo1@bar.com',
},
{
handle: 'handle2',
name: 'Fred',
email: 'foo2@bar.com',
},
{
handle: 'handle3',
name: 'Sue',
email: 'foo3@bar.com',
},
];
export const POSTS: Insertable<Posts>[] = [
{
userId: 0,
title: 'About Something',
likeCount: 0,
},
{
userId: 0,
title: 'And Another Thing',
likeCount: 10,
},
{
userId: 0,
title: 'Still One More Thing',
likeCount: 1000,
},
];
export const userRow1 = {
name: 'John Smith',
handle: 'jsmith',
email: 'jsmith@xyz.pdq',
};
export const userRow2 = {
name: 'Jane Doe',
handle: 'jdoe',
email: 'jdoe@xyz.pdq',
};
export const userRow3 = {
name: 'Mary Sue',
handle: 'msue',
email: 'msue@xyz.pdq',
};
export const userObject1 = {
firstName: 'John',
lastName: 'Smith',
handle: userRow1.handle,
email: userRow1.email,
};
export const userObject2 = {
firstName: 'Jane',
lastName: 'Doe',
handle: userRow2.handle,
email: userRow2.email,
};
export const userObject3 = {
firstName: 'Mary',
lastName: 'Sue',
handle: userRow3.handle,
email: userRow3.email,
};
|
export const selectedUser1 = SelectedUser.create(1, userObject1);
|
export const selectedUser2 = SelectedUser.create(2, userObject2);
export const selectedUser3 = SelectedUser.create(3, userObject3);
export const insertedUser1 = InsertedUser.create(0, userObject1);
export const insertedUser2 = InsertedUser.create(0, userObject2);
export const insertedUser3 = InsertedUser.create(0, userObject3);
export const insertReturnedUser1 = ReturnedUser.create(1, userObject1);
export const insertReturnedUser2 = ReturnedUser.create(2, userObject2);
export const insertReturnedUser3 = ReturnedUser.create(3, userObject3);
|
src/tests/utils/test-objects.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names[1],\n handle: row.handle,\n email: row.email,\n });\n },\n });\n // test returnOne()\n const names1 = userRow1.name.split(' ');\n const expectedUser1 = SelectedUser.create(1, {\n firstName: names1[0],",
"score": 0.9157181978225708
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " email: userRow2.email,\n });\n const names3 = userRow3.name.split(' ');\n const expectedUser3 = SelectedUser.create(3, {\n firstName: names3[0],\n lastName: names3[1],\n handle: userRow3.handle,\n email: userRow3.email,\n });\n const insertReturns = await transformMapper",
"score": 0.8959826231002808
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " handle: source.handle,\n email: source.email,\n };\n }\n return source;\n },\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return SelectedUser.create(row.id, {\n firstName: names[0],",
"score": 0.8882226347923279
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names1[1],\n handle: userRow1.handle,\n email: userRow1.email,\n });\n const insertReturn = await transformMapper.insert().returnOne(userRow1);\n expect(insertReturn).toEqual(expectedUser1);\n // ensure return type can be accessed as a SelectedUser\n ((_: string) => {})(insertReturn.firstName);\n const readUser = await transformMapper\n .select({",
"score": 0.8780941963195801
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " user.handle,\n user.email\n );\n },\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new MappedUser(\n row.id,\n names[0],\n names[1],",
"score": 0.877980649471283
}
] |
typescript
|
export const selectedUser1 = SelectedUser.create(1, userObject1);
|
import { Kysely, sql } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningIDAndHandleAsH,
createUserMapperReturningAll,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningIDAndHandleAsH: ReturnType<
typeof createUserMapperReturningIDAndHandleAsH
>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningIDAndHandleAsH =
createUserMapperReturningIDAndHandleAsH(db);
userMapperReturningAll = createUserMapperReturningAll(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('general update', () => {
it('updates nothing returning zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const success = await userMapperReturningAll
.update({ id: 1 })
.run(updateValues);
expect(success).toBe(false);
const updateCount = await userMapperReturningAll
.update({ id: 1 })
.returnCount(updateValues);
expect(updateCount).toEqual(0);
const updates = await userMapperReturningID
.update({ id: 1 })
.returnAll(updateValues);
expect(updates.length).toEqual(0);
const update = await userMapperReturningID
.update({ id: 1 })
.returnOne(updateValues);
expect(update).toBeNull();
});
it('updates something returning non-zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const insertReturn0 = await userMapperReturningID
.insert()
.returnOne(USERS[0]);
await userMapperReturningID.insert().run(USERS[1]);
await userMapperReturningID.insert().run(USERS[2]);
const updateCount1 = await userMapperReturningAll
.update({ id: insertReturn0.id })
.returnCount(updateValues);
expect(updateCount1).toEqual(1);
const readUser1 = await userMapperReturningID
.select('id', '=', insertReturn0.id)
.returnOne();
expect(readUser1?.email).toEqual(updateValues.email);
const updateCount2 = await userMapperReturningAll
.update({ name: 'Sue' })
.returnCount(updateValues);
expect(updateCount2).toEqual(2);
const readUsers = await userMapperReturningID
.select('name', '=', 'Sue')
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].email).toEqual(updateValues.email);
expect(readUsers[1].email).toEqual(updateValues.email);
const updates = await userMapperReturningID.update().returnAll({
name: 'Every User 1',
});
expect(updates).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
const update = await userMapperReturningID
.update({ id: readUsers[0].id })
.returnOne({
name: 'Every User 2',
});
expect(update).toEqual({ id: 1 });
const readUser2 = await userMapperReturningID
.select('id', '=', 1)
.returnOne();
expect(readUser2?.name).toEqual('Every User 2');
const updateCount = await userMapperReturningID.update().returnCount({
name: 'Every User 3',
});
expect(updateCount).toEqual(3);
const success = await userMapperReturningID.update().run({
name: 'Every User 4',
});
expect(success).toBe(true);
});
it('updates returning configured return columns', async () => {
await userMapperReturningID.insert().run(USERS[0]);
const insertReturn = await userMapperReturningID
.insert()
.returnOne(USERS[1]);
await userMapperReturningID.insert().run(USERS[2]);
// Verify that update performs the correct change on the correct row.
const updateValues1 = { email: 'new.email@xyz.pdq' };
const updateReturns1 = await userMapperReturningID
.update({ id: insertReturn.id })
.returnAll(updateValues1);
expect(updateReturns1).toEqual([{ id: insertReturn.id }]);
let readUser = await userMapperReturningID
.select('id', '=', insertReturn.id)
.returnOne();
expect(readUser?.email).toEqual(updateValues1.email);
// Verify a different change on the same row, returning multiple columns.
const updateValues2 = { name: 'Sue' };
const updateReturns2 = await userMapperReturningIDAndHandleAsH
.update({ email: updateValues1.email })
.returnAll(updateValues2);
updateReturns2[0].id; // ensure key is accessible
updateReturns2[0].h; // ensure key is accessible
expect(updateReturns2).toEqual([
{
id: insertReturn.id,
h: USERS[1].handle,
},
]);
readUser = await userMapperReturningID
.select('id', '=', insertReturn.id)
.returnOne();
expect(readUser?.name).toEqual(updateValues2.name);
// Verify that update changes all required rows.
const updateValues3 = { name: 'Replacement Sue' };
const updateReturns3 = await userMapperReturningIDAndHandleAsH
.update({ name: 'Sue' })
.returnAll(updateValues3);
expect(updateReturns3.length).toEqual(3);
expect(updateReturns3[0].h).toEqual(USERS[0].handle);
expect(updateReturns3[1].h).toEqual(USERS[1].handle);
expect(updateReturns3[2].h).toEqual(USERS[2].handle);
const readUsers = await userMapperReturningID
.select('name', '=', updateValues3.name)
.returnAll();
expect(readUsers.length).toEqual(3);
ignore('check return types', () => {
// @ts-expect-error - check return types
updateReturns2[0].title;
// @ts-expect-error - check return types
updateReturns2[0].userId;
});
});
it('update returns void when defaulting to no return columns', async () => {
await userMapperReturningID.insert().run(USERS);
const updates = await userMapperReturningDefault
.update({ name: 'Sue' })
.returnAll({ email: 'new.email@xyz.pdq' });
expect(updates).toBeUndefined();
const readUsers = await userMapperReturningID
.select({
email: 'new.email@xyz.pdq',
})
.returnAll();
expect(readUsers.length).toEqual(2);
});
it('update returns void when explicitly no return columns', async () => {
await userMapperReturningID.insert().run(USERS);
const updates = await userMapperReturningNothing
.update({ name: 'Sue' })
.returnAll({ email: 'new.email@xyz.pdq' });
expect(updates).toBeUndefined();
const readUsers = await userMapperReturningID
.select({
email: 'new.email@xyz.pdq',
})
.returnAll();
expect(readUsers.length).toEqual(2);
const update = await userMapperReturningNothing
.update({ name: 'Sue' })
.returnOne({ email: 'new2.email@xyz.pdq' });
expect(update).toBeUndefined();
const readUser = await userMapperReturningID
.select({
email: 'new2.email@xyz.pdq',
})
.returnOne();
expect(readUser!.id).toEqual(1);
ignore('type errors', () => {
// @ts-expect-error - check return types
updates[0].id;
// @ts-expect-error - check return types
update!.id;
});
});
it('updates configured to return all columns', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues1 = { email: 'new.email@xyz.pdq' };
const updateReturns = await userMapperReturningAll
.update({ name: 'Sue' })
.returnAll(updateValues1);
const expectedUsers = [
Object.assign({}, USERS[0], updateValues1, { id: insertReturns[0].id }),
Object.assign({}, USERS[2], updateValues1, { id: insertReturns[2].id }),
];
expect(updateReturns).toEqual(expectedUsers);
// Ensure that the returned value can be accessed as a row.
((_: string) => {})(updateReturns[0].name);
((_: string | null) => {})(updateReturns[0].email);
const updateValues2 = { email: 'another.email@xyz.pdq' };
const updateReturn = await userMapperReturningAll
.update({ name: 'Sue' })
.returnOne(updateValues2);
const expectedUser = Object.assign({}, USERS[0], updateValues2, {
id: insertReturns[0].id,
});
expect(updateReturn).toEqual(expectedUser);
// Ensure that the returned value can be accessed as a row.
((_: string) => {})(updateReturn!.name);
((_: string | null) => {})(updateReturn!.email);
});
it('updates all rows when no filter is given', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { email: 'new.email@xyz.pdq' };
const updateReturns = await userMapperReturningIDAndHandleAsH
.update()
.returnAll(updateValues);
|
const expectedUsers = USERS.map((user, i) => ({
|
id: insertReturns[i].id,
h: user.handle,
}));
expect(updateReturns).toEqual(expectedUsers);
const readUsers = await userMapperReturningID.select().returnAll();
expect(readUsers.length).toEqual(3);
for (const user of readUsers) {
expect(user.email).toEqual(updateValues.email);
}
});
it('updates rows indicated by a binary operator', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { email: 'new.email@xyz.pdq' };
const updateCount = await userMapperReturningAll
.update('id', '>', insertReturns[0].id)
.returnCount(updateValues);
expect(updateCount).toEqual(2);
const readUsers = await userMapperReturningID
.select('id', '>', insertReturns[0].id)
.returnAll();
expect(readUsers.length).toEqual(2);
for (const user of readUsers) {
expect(user.email).toEqual(updateValues.email);
}
});
it('updates rows indicated by a kysely expression', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { email: 'new.email@xyz.pdq' };
const updateCount = await userMapperReturningDefault
.update(sql`id > ${insertReturns[0].id}`)
.returnCount(updateValues);
expect(updateCount).toEqual(BigInt(2));
const readUsers = await userMapperReturningID
.select('id', '>', insertReturns[0].id)
.returnAll();
expect(readUsers.length).toEqual(2);
for (const user of readUsers) {
expect(user.email).toEqual(updateValues.email);
}
});
it('updates rows indicated by a where expression filter', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues1 = { email: 'foo@xyz.pdq' };
const updateCount = await userMapperReturningAll
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnCount(updateValues1);
expect(updateCount).toEqual(2);
const updateValues2 = { email: 'bar@xyz.pdq' };
const updateReturns = await userMapperReturningID
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updateValues2);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
});
ignore('detects update type errors', async () => {
userMapperReturningID.update(
// @ts-expect-error - table must have all filter fields
{ notThere: 'xyz' }
);
// @ts-expect-error - table must have all filter fields
userMapperReturningID.update('notThere', '=', 'foo');
userMapperReturningID.update(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via anyOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
// @ts-expect-error - ID filter must have correct type
userMapperReturningID.update('str');
// @ts-expect-error - ID filter must have correct type
userMapperReturningID.update(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.update(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.update([1]);
userMapperReturningID.update({ id: 32 }).returnAll(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).returnAll(USERS[0]))[0].name;
userMapperReturningID.update({ id: 32 }).returnOne(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).returnOne(USERS[0]))[0].name;
userMapperReturningID.update({ id: 32 }).returnCount(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).returnCount(USERS[0]))[0].name;
userMapperReturningID.update({ id: 32 }).run(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).run(USERS[0]))[0].name;
});
});
|
src/tests/update-general.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " // @ts-expect-error - check return types\n updateReturns[0].userId;\n });\n });\n it('inserts multiple returning no columns by default', async () => {\n const insertReturns = await userMapperReturningDefault\n .insert()\n .returnAll(USERS);\n expect(insertReturns).toBeUndefined();\n const readUsers = await userMapperReturningAll.select().returnAll();",
"score": 0.9180256724357605
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " ((_: string) => {})(updateReturns[0].name);\n ignore('type errors', () => {\n // @ts-expect-error - check return types\n insertReturns[0].name;\n // @ts-expect-error - check return types\n updateReturns[0].id;\n });\n });\n it('inserts multiple configured to return all columns', async () => {\n const insertReturns = await userMapperReturningAll",
"score": 0.9144692420959473
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " );\n });\n });\n it('requires all indicated columns to be updated', async () => {\n await userMapperReturningID.insert().run(USERS);\n const compilation = userMapperReturningID\n .update()\n .columns(['name', 'handle', 'email'])\n .compile();\n const updateValues = { name: 'John Doe', handle: 'johndoe' };",
"score": 0.9137200117111206
},
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " handle: USERS[0].handle,\n });\n });\n it('subsets updating columns, including ID', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const updateValues = { id: 100, name: 'Sue Rex', email: 'rex@abc.def' };\n const subsetQuery = userMapperReturningID\n .update('id', '=', insertReturns[0].id)\n .columns(['id', 'name', 'email']);\n const updateReturns = await subsetQuery.returnAll(updateValues);",
"score": 0.9134348630905151
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " // test returnAll()\n const updateReturns3 = await parameterization.returnAll(\n { id: insertReturns[2].id },\n updateValues1\n );\n expect(updateReturns3[0].id).toEqual(insertReturns[2].id);\n expect(updateReturns3[0].h).toEqual(USERS[2].handle);\n // verify updates\n const readUsers = await userMapperReturningID.select().returnAll();\n expect(readUsers[0].name).toEqual(updateValues1.name);",
"score": 0.9119184613227844
}
] |
typescript
|
const expectedUsers = USERS.map((user, i) => ({
|
import { Kysely, InsertQueryBuilder, InsertResult, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { SubsettingMappingInsertQuery } from './subsetting-insert-query';
import { MappingInsertQuery } from './insert-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Mapping query for inserting rows into a database table, where the
* columns to be inserted have not been restricted.
*/
export class AnyColumnsMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, InsertResult>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends MappingInsertQuery<
DB,
TB,
QB,
InsertedObject,
InsertReturnColumns,
InsertReturn
> {
constructor(
db: Kysely<DB>,
qb: QB,
transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a mapping query that only inserts a specified subset of columns.
* @param columns The columns to insert. All are required, but this
* constraint is only enforced at runtime, not by the type system.
* @returns A mapping query that only inserts the specified columns.
*/
columns(
columnsToInsert: Readonly<(keyof Insertable<DB[TB]> & string)[]>
): SubsettingMappingInsertQuery<
DB,
TB,
QB,
InsertedObject,
InsertReturnColumns,
InsertReturn
> {
return new SubsettingMappingInsertQuery(
this.db,
this
|
.qb,
columnsToInsert,
this.transforms,
this.returnColumns
);
|
}
}
|
src/queries/any-insert-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/queries/any-update-query.ts",
"retrieved_chunk": " ReturnCount,\n UpdateReturn\n > {\n return new SubsettingMappingUpdateQuery(\n this.db,\n this.qb,\n columnsToUpdate,\n this.transforms,\n this.returnColumns\n );",
"score": 0.9373561143875122
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " InsertedObject,\n InsertReturnColumns,\n InsertReturn\n > {\n return new AnyColumnsMappingInsertQuery(\n this.db,\n this.getInsertQB(),\n this.transforms,\n this.insertReturnColumns as InsertReturnColumns\n );",
"score": 0.9079020023345947
},
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": "export class SubsettingMappingInsertQuery<\n DB,\n TB extends keyof DB & string,\n QB extends InsertQueryBuilder<DB, TB, InsertResult>,\n InsertedObject,\n InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],\n InsertReturn\n> extends MappingInsertQuery<\n DB,\n TB,",
"score": 0.8782669305801392
},
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " > {\n return new CompilingMappingInsertQuery(\n this.db,\n this.qb,\n this.columnsToInsert,\n this.transforms,\n this.returnColumns\n );\n }\n protected override getInsertColumns():",
"score": 0.8709529638290405
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " InsertReturn,\n UpdateReturn,\n this,\n Parameters,\n SubsettingMappingUpdateQuery<\n DB,\n TB,\n UpdateQueryBuilder<DB, TB, TB, UpdateResult>,\n UpdatingObject,\n UpdateReturnColumns,",
"score": 0.868582010269165
}
] |
typescript
|
.qb,
columnsToInsert,
this.transforms,
this.returnColumns
);
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
userObject1,
userRow1,
userRow2,
userRow3,
} from './utils/test-objects';
import { ReturnedUser, UpdatingUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating with transformation', () => {
it('transforms users for update without transforming return', async () => {
const mapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
});
const insertReturns = await mapper
.insert()
.returnAll([userRow1, userRow2, userRow3]);
const updatingUser1 = UpdatingUser.create(
0,
Object.assign({}, userObject1, { firstName: 'Suzanne' })
);
const updateReturns = await mapper
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updatingUser1);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
const readUsers = await mapper
.select()
.modify((qb) => qb.orderBy('id'))
.returnAll();
expect(readUsers).toEqual([
Object.assign({}, userRow1, {
id: insertReturns[0].id,
name: 'Suzanne Smith',
}),
Object.assign({}, userRow2, { id: insertReturns[1].id }),
Object.assign({}, userRow1, {
id: insertReturns[2].id,
name: 'Suzanne Smith',
}),
]);
});
it('transforms update return into object without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateReturnTransform: (source, returns) =>
new ReturnedUser(
returns.id,
source.name ? source.name.split(' ')[0] : '(first)',
source.name ? source.name.split(' ')[1] : '(last)',
source.handle ? source.handle : '(handle)',
source.email ? source.email : '(email)'
),
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smith',
'(handle)',
'(email)'
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn1[0].firstName);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smithy',
'(handle)',
'(email)'
)
);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn2!.firstName);
});
it('transforms update return into primitive without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
updateReturnTransform: (_source, returns) => returns.id,
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([1]);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn1[0]);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(1);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn2!);
});
it("transforms update and update return, columns is ['*']", async () => {
expect.assertions(2);
const updateAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source:
|
UpdatingUser, columns) => {
|
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (source: UpdatingUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
});
const insertReturn = await updateAndReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn = await updateAndReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll(UpdatingUser.create(0, userObject1));
expect(updateReturn).toEqual([
new ReturnedUser(
insertReturn.id,
userObject1.firstName,
userObject1.lastName,
userObject1.handle,
userObject1.email
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn[0].firstName);
});
it('transforms a union of updating object types', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser | Updateable<Users>) =>
source instanceof UpdatingUser
? {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}
: source,
});
const insertReturn = await mapper.insert().returnOne(userRow1);
// test with UpdatingUser
await mapper
.update({ id: insertReturn.id })
.columns(['name'])
.run(UpdatingUser.create(0, userObject1));
const readUser1 = await mapper.select(insertReturn.id).returnOne();
expect(readUser1).toEqual({
id: insertReturn.id,
name: `${userObject1.firstName} ${userObject1.lastName}`,
email: userRow1.email,
handle: userRow1.handle,
});
// test with Updateable<Users>
const newName = 'Suzanne Smith Something';
await mapper.update({ id: insertReturn.id }).run({ name: newName });
const readUser2 = await mapper.select(insertReturn.id).returnOne();
expect(readUser2).toEqual({
id: insertReturn.id,
name: newName,
email: userRow1.email,
handle: userRow1.handle,
});
});
});
|
src/tests/update-transform.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(insertReturns).toEqual([2, 3]);\n // ensure return type can be accessed as a number\n ((_: number) => {})(insertReturns[0]);\n });\n it(\"transforms insertion and insertion return, columns is ['*']\", async () => {\n expect.assertions(5);\n const insertAndReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser, columns) => {",
"score": 0.9384346604347229
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });\n // ensure return type can be accessed as a row\n ((_: string) => {})(updatedUser!.name);\n });\n it('transforms insertion return into primitive without transforming insertion', async () => {\n const insertReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n insertReturnTransform: (_source, returns) => returns.id,\n countTransform: (count) => Number(count),",
"score": 0.9231930375099182
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(updateReturn1!.firstName);\n const readUser1 = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser1).toEqual(expectedUser1);\n // test returnAll()\n const updateReturn2 = await compilation.returnAll({}, user2);\n const expectedUser2 = User.create(insertReturns[2].id, {\n firstName: user2.firstName,",
"score": 0.9197463393211365
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " // test that updates return rows\n const updateReturn = await transformMapper\n .update({ id: 1 })\n .returnOne(expectedUser2);\n expect(updateReturn).toEqual({\n id: 1,\n name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,\n });\n // ensure return type can be accessed as a row\n ((_: string) => {})(updateReturn!.name);",
"score": 0.9192990064620972
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " });\n it('transforms insertion return into object without transforming insertion', async () => {\n const insertReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id', 'name'],\n updateReturnColumns: ['id', 'name'],\n }).withTransforms({\n insertReturnTransform: (source, returns) => {\n const names = returns.name.split(' ');\n return new ReturnedUser(\n returns.id,",
"score": 0.9163000583648682
}
] |
typescript
|
UpdatingUser, columns) => {
|
import { Insertable } from 'kysely';
import { Users, Posts } from './test-tables';
import { InsertedUser, ReturnedUser, SelectedUser } from './test-types';
export const USERS: Insertable<Users>[] = [
{
handle: 'handle1',
name: 'Sue',
email: 'foo1@bar.com',
},
{
handle: 'handle2',
name: 'Fred',
email: 'foo2@bar.com',
},
{
handle: 'handle3',
name: 'Sue',
email: 'foo3@bar.com',
},
];
export const POSTS: Insertable<Posts>[] = [
{
userId: 0,
title: 'About Something',
likeCount: 0,
},
{
userId: 0,
title: 'And Another Thing',
likeCount: 10,
},
{
userId: 0,
title: 'Still One More Thing',
likeCount: 1000,
},
];
export const userRow1 = {
name: 'John Smith',
handle: 'jsmith',
email: 'jsmith@xyz.pdq',
};
export const userRow2 = {
name: 'Jane Doe',
handle: 'jdoe',
email: 'jdoe@xyz.pdq',
};
export const userRow3 = {
name: 'Mary Sue',
handle: 'msue',
email: 'msue@xyz.pdq',
};
export const userObject1 = {
firstName: 'John',
lastName: 'Smith',
handle: userRow1.handle,
email: userRow1.email,
};
export const userObject2 = {
firstName: 'Jane',
lastName: 'Doe',
handle: userRow2.handle,
email: userRow2.email,
};
export const userObject3 = {
firstName: 'Mary',
lastName: 'Sue',
handle: userRow3.handle,
email: userRow3.email,
};
export const selectedUser1 = SelectedUser.create(1, userObject1);
export const selectedUser2 = SelectedUser.create(2, userObject2);
export const selectedUser3 = SelectedUser.create(3, userObject3);
|
export const insertedUser1 = InsertedUser.create(0, userObject1);
|
export const insertedUser2 = InsertedUser.create(0, userObject2);
export const insertedUser3 = InsertedUser.create(0, userObject3);
export const insertReturnedUser1 = ReturnedUser.create(1, userObject1);
export const insertReturnedUser2 = ReturnedUser.create(2, userObject2);
export const insertReturnedUser3 = ReturnedUser.create(3, userObject3);
|
src/tests/utils/test-objects.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names[1],\n handle: row.handle,\n email: row.email,\n });\n },\n });\n // test returnOne()\n const names1 = userRow1.name.split(' ');\n const expectedUser1 = SelectedUser.create(1, {\n firstName: names1[0],",
"score": 0.8965035676956177
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " email: userRow2.email,\n });\n const names3 = userRow3.name.split(' ');\n const expectedUser3 = SelectedUser.create(3, {\n firstName: names3[0],\n lastName: names3[1],\n handle: userRow3.handle,\n email: userRow3.email,\n });\n const insertReturns = await transformMapper",
"score": 0.8923545479774475
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " id: insertReturn.id,\n })\n .returnOne();\n expect(readUser).toEqual(expectedUser1);\n // test returnAll()\n const names2 = userRow2.name.split(' ');\n const expectedUser2 = SelectedUser.create(2, {\n firstName: names2[0],\n lastName: names2[1],\n handle: userRow2.handle,",
"score": 0.8900996446609497
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names1[1],\n handle: userRow1.handle,\n email: userRow1.email,\n });\n const insertReturn = await transformMapper.insert().returnOne(userRow1);\n expect(insertReturn).toEqual(expectedUser1);\n // ensure return type can be accessed as a SelectedUser\n ((_: string) => {})(insertReturn.firstName);\n const readUser = await transformMapper\n .select({",
"score": 0.8834894895553589
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " .insert()\n .returnAll([userRow1, userRow2, userRow3]);\n const updatingUser1 = UpdatingUser.create(\n 0,\n Object.assign({}, userObject1, { firstName: 'Suzanne' })\n );\n const updateReturns = await mapper\n .update(({ or, cmpr }) =>\n or([\n cmpr('id', '=', insertReturns[0].id),",
"score": 0.876975417137146
}
] |
typescript
|
export const insertedUser1 = InsertedUser.create(0, userObject1);
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningIDAndHandleAsH,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { User } from './utils/test-types';
let db: Kysely<Database>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningIDAndHandleAsH: ReturnType<
typeof createUserMapperReturningIDAndHandleAsH
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningIDAndHandleAsH =
createUserMapperReturningIDAndHandleAsH(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('compiled updates', () => {
it('updates nothing returning zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const compilation = userMapperReturningID
.update({ id: 1 })
.columns(['email'])
.compile();
const success2 = await compilation.run({}, updateValues);
expect(success2).toBe(false);
const updateCount2 = await compilation.returnCount({}, updateValues);
expect(updateCount2).toEqual(0);
const updates2 = await compilation.returnAll({}, updateValues);
expect(updates2.length).toEqual(0);
const update2 = await compilation.returnOne({}, updateValues);
expect(update2).toBeNull();
});
it('compilations accept readonly updating objects', async () => {
const compilation = userMapperReturningNothing
.update('id', '=', 1)
.columns(['name', 'email'])
.compile();
const updateValues1 = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
await compilation.run({}, updateValues1);
});
it('compiles a non-returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningNothing
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = {
name: 'Johnny Rex' as const,
email: 'jrex@abc.def' as const,
} as const;
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2).toBeUndefined();
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3).toBeUndefined();
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
});
it('compiles a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningIDAndHandleAsH
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = { name: 'Sue Rex', email: 'srex@abc.def' };
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex', email: 'jrex@abc.def' };
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2?.id).toEqual(insertReturns[0].id);
expect(updateReturns2?.h).toEqual(USERS[0].handle);
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3[0].id).toEqual(insertReturns[0].id);
expect(updateReturns3[0].h).toEqual(USERS[0].handle);
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
ignore('check compile-time types', () => {
compilation.returnOne(
{},
{
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
// @ts-expect-error - only insertable columns are allowed
notThere: 32,
}
);
// @ts-expect-error - only expected columns are returned
updateReturns2!.handle;
// @ts-expect-error - only expected columns are returned
updateReturns3[0].handle;
});
});
it('accepts readonly parameters and updating objects', async () => {
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
const params = { id: 1 as const } as const;
const updateValues = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
await parameterization.run(params, updateValues);
await parameterization.returnAll(params, updateValues);
await parameterization.returnOne(params, updateValues);
await parameterization.returnCount(params, updateValues);
});
it('parameterizes a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test run()
const updateValues1 = { name: 'Sue Rex' };
const updateReturns1 = await parameterization.run(
{ id: insertReturns[0].id },
updateValues1
);
expect(updateReturns1).toBe(true);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex' };
const updateReturns2 = await parameterization.returnOne(
{ id: insertReturns[1].id },
updateValues2
);
expect(updateReturns2?.id).toEqual(insertReturns[1].id);
expect(updateReturns2?.h).toEqual(USERS[1].handle);
// test returnAll()
const updateReturns3 = await parameterization.returnAll(
{ id: insertReturns[2].id },
updateValues1
);
expect(updateReturns3[0].id).toEqual(insertReturns[2].id);
expect(updateReturns3[0].h).toEqual(USERS[2].handle);
// verify updates
const readUsers = await userMapperReturningID.select().returnAll();
expect(readUsers[0].name).toEqual(updateValues1.name);
expect(readUsers[1].name).toEqual(updateValues2.name);
expect(readUsers[2].name).toEqual(updateValues1.name);
// test returnCount()
const updateReturns4 = await parameterization.returnCount(
{ id: insertReturns[0].id },
updateValues2
);
expect(updateReturns4).toEqual(1);
const readUser = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser?.name).toEqual(updateValues2.name);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid column names
updateReturns2!.handle;
// @ts-expect-error - errors on invalid column names
updateReturns3[0].handle;
userMapperReturningIDAndHandleAsH.parameterize<{ id: number }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
userMapperReturningIDAndHandleAsH.parameterize<{ id: string }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, updateValues1);
parameterization.returnOne(
{ id: 1 },
{
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
// @ts-expect-error - only updateable columns are allowed
notThere: 32,
}
);
});
});
it('compiles an update query with transformation', async () => {
expect.assertions(12);
const columnSubset: (keyof Updateable<Users>)[] = ['name'];
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['*'],
updateReturnColumns: ['*'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
insertReturnTransform: (_source, returns) => {
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
|
updateTransform: (source: User, columns) => {
|
expect(columns).toEqual(columnSubset);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (_source, returns) => {
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');
const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const compilation = transformMapper
.update({ id: insertReturns[2].id })
.columns(columnSubset)
.compile();
// test returnOne()
const updateReturn1 = await compilation.returnOne({}, user1);
const expectedUser1 = User.create(insertReturns[2].id, {
firstName: user1.firstName,
lastName: user1.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn1).toEqual(expectedUser1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
const readUser1 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser1).toEqual(expectedUser1);
// test returnAll()
const updateReturn2 = await compilation.returnAll({}, user2);
const expectedUser2 = User.create(insertReturns[2].id, {
firstName: user2.firstName,
lastName: user2.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn2[0]).toEqual(expectedUser2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
const readUser2 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser2).toEqual(expectedUser2);
// test run()
const success1 = await compilation.run({}, user1);
expect(success1).toBe(true);
const readUser3 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser3).toEqual(expectedUser1);
// test returnCount()
const count = await compilation.returnCount({}, user2);
expect(count).toEqual(1);
const readUser4 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser4).toEqual(expectedUser2);
ignore('check compile-time types', async () => {
// @ts-expect-error - only update objects are allowed
compilation.returnOne({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnAll({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnCount({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.run({}, USERS[0]);
// @ts-expect-error - correct return is expected
(await compilation.returnOne({}, user1))!.name;
// @ts-expect-error - correct return is expected
(await compilation.returnAll({}, user2))[0].name;
});
});
it('parameterizes an update query with transformation', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
insertReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
updateTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
updateReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');
const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const parameterization = transformMapper.parameterize<{ id: number }>(
({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test returnOne()
const updateReturn1 = await parameterization.returnOne(
{ id: insertReturns[0].id },
user2
);
const expectedReturn1 = {
id: insertReturns[0].id,
firstName: user2.firstName,
lastName: user2.lastName,
};
expect(updateReturn1).toEqual(expectedReturn1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
// test returnAll()
const updateReturn2 = await parameterization.returnAll(
{ id: insertReturns[1].id },
user3
);
const expectedReturn2 = {
id: insertReturns[1].id,
firstName: user3.firstName,
lastName: user3.lastName,
};
expect(updateReturn2[0]).toEqual(expectedReturn2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
// test run()
const success1 = await parameterization.run(
{ id: insertReturns[2].id },
user1
);
const expectedReturn3 = {
id: insertReturns[2].id,
firstName: user1.firstName,
lastName: user1.lastName,
};
expect(success1).toBe(true);
// verify updates
const readUsers = await transformMapper.select().returnAll();
expect(readUsers).toEqual([
User.create(expectedReturn1.id, {
...expectedReturn1,
handle: user1.handle,
email: user1.email!,
}),
User.create(expectedReturn2.id, {
...expectedReturn2,
handle: user2.handle,
email: user2.email!,
}),
User.create(expectedReturn3.id, {
...expectedReturn3,
handle: user3.handle,
email: user3.email!,
}),
]);
// test returnCount()
const count = await parameterization.returnCount(
{ id: insertReturns[2].id },
user2
);
expect(count).toEqual(1);
const readUser = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser).toEqual(
User.create(insertReturns[2].id, {
...expectedReturn1,
handle: user3.handle,
email: user3.email!,
})
);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid column names
updateReturn1!.handle;
// @ts-expect-error - errors on invalid column names
updateReturn2[0].handle;
transformMapper.parameterize<{ id: number }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
transformMapper.parameterize<{ id: string }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, user1);
parameterization.returnOne(
{ id: 1 },
{
// @ts-expect-error - only updateable columns are allowed
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
}
);
});
});
it('requires all indicated columns to be updated', async () => {
await userMapperReturningID.insert().run(USERS);
const compilation = userMapperReturningID
.update()
.columns(['name', 'handle', 'email'])
.compile();
const updateValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => compilation.returnOne({}, updateValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await compilation.run({}, { ...updateValues, email: null });
expect(success).toBe(true);
});
});
|
src/tests/update-compile.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " updateTransform: (source: UpdatingUser, columns) => {\n expect(columns).toEqual(['*']);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n updateReturnTransform: (source: UpdatingUser, returns) =>\n new ReturnedUser(",
"score": 0.9316074848175049
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(columns).toEqual(['*']);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n insertReturnTransform: (source: InsertedUser, returns) =>\n new ReturnedUser(\n returns.id,",
"score": 0.9262596368789673
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " insertTransform: (source: User, columns) => {\n expect(columns).toEqual(columnSubset);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n insertReturnTransform: (source: User, returns) =>\n new User(",
"score": 0.9069285988807678
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " new ReturnedUser(\n returns.id,\n source.name ? source.name.split(' ')[0] : '(first)',\n source.name ? source.name.split(' ')[1] : '(last)',\n source.handle ? source.handle : '(handle)',\n source.email ? source.email : '(email)'\n ),\n });\n const insertReturn = await updateReturnTransformMapper\n .insert()",
"score": 0.902332067489624
},
{
"filename": "src/tests/utils/test-mappers.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n countTransform: (count) => Number(count),\n });\n}",
"score": 0.9013012051582336
}
] |
typescript
|
updateTransform: (source: User, columns) => {
|
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { ParametersObject } from 'kysely-params';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for updating rows in a database table.
*/
export class CompilingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn,
Parameters extends ParametersObject<Parameters>
> extends CompilingValuesQuery<
DB,
TB,
QB,
UpdateReturnColumns,
Parameters,
Updateable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToUpdate);
this
|
.qb = qb.set(parameterizedValues) as QB;
|
}
/**
* Runs the query, returning the number of rows updated, in the required
* client representation. Accepts values for any parameters embedded in
* the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns Number of rows updated, in client-requested representation.
*/
async returnCount(
params: Parameters,
obj: UpdatingObject
): Promise<ReturnCount> {
const transformedObj = this.applyUpdateTransform(obj);
const compiledQuery = this.instantiateNoReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.countTransform === undefined
? (result.numAffectedRows as ReturnCount)
: this.transforms.countTransform(result.numAffectedRows!);
}
/**
* Updates rows with the values that result from transforming the object via
* `insertTransform` (if defined). For each row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an array containing one
* object for each row updated; otherwise returns `undefined`.
*/
returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;
async returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn[] | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.updateReturnTransform === undefined
? (result.rows as any)
: result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
);
}
/**
* Updates rows with the values that result from transforming the object via
* `updateTransform` (if defined). For the first row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is empty, returns `undefined`. Otherwise,
* returns the first object if at least one row was updated, or `null` if
* no rows were updated.
*/
returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;
async returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn | null | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
return null;
}
return this.applyUpdateReturnTransform(
obj as UpdatingObject,
result.rows[0] as any
);
}
/**
* Runs the query, updating rows, without returning any columns. Accepts
* values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns `true` if any rows were updated, `false` otherwise.
*/
async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {
return (await this.returnCount(params, obj)) !== 0;
}
protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {
return this.transforms.updateTransform === undefined
? (obj as Updateable<DB[TB]>)
: this.transforms.updateTransform(obj, this.columnsToUpdate);
}
protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {
return this.transforms.updateReturnTransform === undefined
? (returns as any)
: this.transforms.updateReturnTransform(source, returns);
}
}
|
src/queries/compiling-update-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " ReturnCount,\n UpdateReturn\n >\n implements ParameterizableMappingQuery\n{\n constructor(\n db: Kysely<DB>,\n qb: QB,\n protected readonly columnsToUpdate: Readonly<\n (keyof Updateable<DB[TB]> & string)[]",
"score": 0.8961665630340576
},
{
"filename": "src/queries/any-update-query.ts",
"retrieved_chunk": " >\n >,\n returnColumns: Readonly<UpdateReturnColumns>\n ) {\n super(db, qb, transforms, returnColumns);\n }\n /**\n * Returns a mapping query that only updates a specified subset of columns.\n * @param columns The columns to update. All are required, but this\n * constraint is only enforced at runtime, not by the type system.",
"score": 0.8897901773452759
},
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],\n ReturnCount,\n UpdateReturn\n >\n extends MappingUpdateQuery<\n DB,\n TB,\n QB,\n UpdatingObject,\n UpdateReturnColumns,",
"score": 0.8897280097007751
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n >\n >,\n returnColumns: Readonly<InsertReturnColumns>\n ) {\n super(db, qb, transforms, returnColumns);\n }",
"score": 0.8824636340141296
},
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn,\n Parameters\n > {\n return new CompilingMappingUpdateQuery(\n this.db,\n this.qb,\n this.columnsToUpdate,",
"score": 0.8782309293746948
}
] |
typescript
|
.qb = qb.set(parameterizedValues) as QB;
|
import { Kysely, InsertQueryBuilder, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for inserting rows into a database table.
*/
export class CompilingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, any>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends CompilingValuesQuery<
DB,
TB,
QB,
InsertReturnColumns,
{},
Insertable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToInsert);
this.qb = qb.values(parameterizedValues) as QB;
}
/**
* Inserts the provided object into the table as a row, first transforming
* it into a row via `insertTransform` (if defined). Also retrieves the
* columns specified in `returnColumns`, returning them to the caller as
* `InsertReturn`, after transformation by `insertReturnTransform`.
* If `returnColumns` is empty, returns `undefined`.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an object;
* otherwise returns `undefined`.
*/
returnOne(
obj: InsertedObject
): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;
async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {
if (this.returnColumns.length === 0) {
await this.run(obj);
return;
}
const transformedObj = this.applyInsertTransform(obj);
|
const compiledQuery = this.instantiateWithReturns({}, transformedObj);
|
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
throw Error(
'No row returned from compiled insert expecting returned columns'
);
}
return this.transforms.insertReturnTransform === undefined
? (result.rows[0] as any)
: this.transforms.insertReturnTransform(obj, result.rows[0] as any);
}
/**
* Runs the query, inserting rows into the table without returning any
* columns.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param objOrObjs The object or objects to be inserted.
* @returns Returns `true`; throws an exception on error.
*/
async run(obj: InsertedObject): Promise<boolean> {
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateNoReturns({}, transformedObj);
await this.db.executeQuery(compiledQuery);
return true;
}
protected applyInsertTransform(obj: InsertedObject): Insertable<DB[TB]> {
return this.transforms.insertTransform === undefined
? (obj as Insertable<DB[TB]>)
: this.transforms.insertTransform(obj, this.columnsToInsert);
}
}
|
src/queries/compiling-insert-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " * @returns If `returnColumns` is not empty, returns an object;\n * otherwise returns `undefined`.\n */\n returnOne(\n obj: InsertedObject\n ): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;\n async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {\n if (this.returnColumns.length === 0) {\n await this.loadInsertedObjects(this.qb, obj).execute();\n return;",
"score": 0.9528645277023315
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;\n async returnOne(obj: UpdatingObject): Promise<UpdateReturn | null | void> {\n if (this.returnColumns.length === 0) {\n await this.loadUpdatingObject(this.qb, obj as UpdatingObject).execute();\n return;\n }\n const returns = await this.loadUpdatingObject(\n this.getReturningQB(),\n obj as UpdatingObject\n ).execute();",
"score": 0.9223233461380005
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " params: Parameters,\n obj: UpdatingObject\n ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;\n async returnOne(\n params: Parameters,\n obj: UpdatingObject\n ): Promise<UpdateReturn | null | void> {\n if (this.returnColumns.length === 0) {\n await this.run(params, obj as UpdatingObject);\n return;",
"score": 0.9220747351646423
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " obj: UpdatingObject\n ): Promise<UpdateReturn[] | void> {\n if (this.returnColumns.length === 0) {\n await this.run(params, obj as UpdatingObject);\n return;\n }\n const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);\n const compiledQuery = this.instantiateWithReturns(params, transformedObj);\n const result = await this.db.executeQuery(compiledQuery);\n return this.transforms.updateReturnTransform === undefined",
"score": 0.9063326120376587
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " }\n const result = await this.loadInsertedObjects(\n this.getReturningQB(),\n obj\n ).executeTakeFirst();\n return this.transforms.insertReturnTransform === undefined\n ? (result as any)\n : this.transforms.insertReturnTransform(obj, result as any);\n }\n /**",
"score": 0.893781304359436
}
] |
typescript
|
const compiledQuery = this.instantiateWithReturns({}, transformedObj);
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
userObject1,
userRow1,
userRow2,
userRow3,
} from './utils/test-objects';
import { ReturnedUser, UpdatingUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating with transformation', () => {
it('transforms users for update without transforming return', async () => {
const mapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
});
const insertReturns = await mapper
.insert()
.returnAll([userRow1, userRow2, userRow3]);
const updatingUser1 = UpdatingUser.create(
0,
Object.assign({}, userObject1, { firstName: 'Suzanne' })
);
const updateReturns = await mapper
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updatingUser1);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
const readUsers = await mapper
.select()
|
.modify((qb) => qb.orderBy('id'))
.returnAll();
|
expect(readUsers).toEqual([
Object.assign({}, userRow1, {
id: insertReturns[0].id,
name: 'Suzanne Smith',
}),
Object.assign({}, userRow2, { id: insertReturns[1].id }),
Object.assign({}, userRow1, {
id: insertReturns[2].id,
name: 'Suzanne Smith',
}),
]);
});
it('transforms update return into object without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateReturnTransform: (source, returns) =>
new ReturnedUser(
returns.id,
source.name ? source.name.split(' ')[0] : '(first)',
source.name ? source.name.split(' ')[1] : '(last)',
source.handle ? source.handle : '(handle)',
source.email ? source.email : '(email)'
),
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smith',
'(handle)',
'(email)'
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn1[0].firstName);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smithy',
'(handle)',
'(email)'
)
);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn2!.firstName);
});
it('transforms update return into primitive without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
updateReturnTransform: (_source, returns) => returns.id,
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([1]);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn1[0]);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(1);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn2!);
});
it("transforms update and update return, columns is ['*']", async () => {
expect.assertions(2);
const updateAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (source: UpdatingUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
});
const insertReturn = await updateAndReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn = await updateAndReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll(UpdatingUser.create(0, userObject1));
expect(updateReturn).toEqual([
new ReturnedUser(
insertReturn.id,
userObject1.firstName,
userObject1.lastName,
userObject1.handle,
userObject1.email
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn[0].firstName);
});
it('transforms a union of updating object types', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser | Updateable<Users>) =>
source instanceof UpdatingUser
? {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}
: source,
});
const insertReturn = await mapper.insert().returnOne(userRow1);
// test with UpdatingUser
await mapper
.update({ id: insertReturn.id })
.columns(['name'])
.run(UpdatingUser.create(0, userObject1));
const readUser1 = await mapper.select(insertReturn.id).returnOne();
expect(readUser1).toEqual({
id: insertReturn.id,
name: `${userObject1.firstName} ${userObject1.lastName}`,
email: userRow1.email,
handle: userRow1.handle,
});
// test with Updateable<Users>
const newName = 'Suzanne Smith Something';
await mapper.update({ id: insertReturn.id }).run({ name: newName });
const readUser2 = await mapper.select(insertReturn.id).returnOne();
expect(readUser2).toEqual({
id: insertReturn.id,
name: newName,
email: userRow1.email,
handle: userRow1.handle,
});
});
});
|
src/tests/update-transform.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " expect(updateReturns).toEqual([{ id: 100 }]);\n const readUsers = await userMapperReturningID\n .select('id', '=', 100)\n .returnOne();\n expect(readUsers).toEqual({\n id: 100,\n name: 'Sue Rex',\n email: 'rex@abc.def',\n handle: USERS[0].handle,\n });",
"score": 0.9380910396575928
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " const updates = await userMapperReturningID.update().returnAll({\n name: 'Every User 1',\n });\n expect(updates).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);\n const update = await userMapperReturningID\n .update({ id: readUsers[0].id })\n .returnOne({\n name: 'Every User 2',\n });\n expect(update).toEqual({ id: 1 });",
"score": 0.9373502731323242
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " const expectedUsers = USERS.map((user, i) => ({\n id: insertReturns[i].id,\n h: user.handle,\n }));\n expect(updateReturns).toEqual(expectedUsers);\n const readUsers = await userMapperReturningID.select().returnAll();\n expect(readUsers.length).toEqual(3);\n for (const user of readUsers) {\n expect(user.email).toEqual(updateValues.email);\n }",
"score": 0.9346951246261597
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " user1\n );\n const expectedReturn3 = {\n id: insertReturns[2].id,\n firstName: user1.firstName,\n lastName: user1.lastName,\n };\n expect(success1).toBe(true);\n // verify updates\n const readUsers = await transformMapper.select().returnAll();",
"score": 0.9327599406242371
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " .insert()\n .returnAll([userRow2, userRow3]);\n expect(insertReturns).toEqual([expectedUser2, expectedUser3]);\n // ensure return type can be accessed as a SelectedUser\n ((_: string) => {})(insertReturns[0].firstName);\n ((_: string) => {})(insertReturns[1].firstName);\n const readUsers = await transformMapper\n .select('id', '>', insertReturn.id)\n .returnAll();\n expect(readUsers).toEqual([expectedUser2, expectedUser3]);",
"score": 0.9303660988807678
}
] |
typescript
|
.modify((qb) => qb.orderBy('id'))
.returnAll();
|
import { Kysely, InsertQueryBuilder, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for inserting rows into a database table.
*/
export class CompilingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, any>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends CompilingValuesQuery<
DB,
TB,
QB,
InsertReturnColumns,
{},
Insertable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, returnColumns);
|
const parameterizedValues = this.getParameterizedObject(columnsToInsert);
|
this.qb = qb.values(parameterizedValues) as QB;
}
/**
* Inserts the provided object into the table as a row, first transforming
* it into a row via `insertTransform` (if defined). Also retrieves the
* columns specified in `returnColumns`, returning them to the caller as
* `InsertReturn`, after transformation by `insertReturnTransform`.
* If `returnColumns` is empty, returns `undefined`.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an object;
* otherwise returns `undefined`.
*/
returnOne(
obj: InsertedObject
): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;
async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {
if (this.returnColumns.length === 0) {
await this.run(obj);
return;
}
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateWithReturns({}, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
throw Error(
'No row returned from compiled insert expecting returned columns'
);
}
return this.transforms.insertReturnTransform === undefined
? (result.rows[0] as any)
: this.transforms.insertReturnTransform(obj, result.rows[0] as any);
}
/**
* Runs the query, inserting rows into the table without returning any
* columns.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param objOrObjs The object or objects to be inserted.
* @returns Returns `true`; throws an exception on error.
*/
async run(obj: InsertedObject): Promise<boolean> {
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateNoReturns({}, transformedObj);
await this.db.executeQuery(compiledQuery);
return true;
}
protected applyInsertTransform(obj: InsertedObject): Insertable<DB[TB]> {
return this.transforms.insertTransform === undefined
? (obj as Insertable<DB[TB]>)
: this.transforms.insertTransform(obj, this.columnsToInsert);
}
}
|
src/queries/compiling-insert-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n >\n >,\n returnColumns: Readonly<InsertReturnColumns>\n ) {\n super(db, qb, transforms, returnColumns);\n }",
"score": 0.9411104917526245
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " UpdateReturnColumns,\n UpdateReturn\n >\n >,\n returnColumns: Readonly<UpdateReturnColumns>\n ) {\n super(db, returnColumns);\n const parameterizedValues = this.getParameterizedObject(columnsToUpdate);\n this.qb = qb.set(parameterizedValues) as QB;\n }",
"score": 0.9004278182983398
},
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " QB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n> {\n constructor(\n db: Kysely<DB>,\n qb: QB,\n protected readonly columnsToInsert: Readonly<\n (keyof Insertable<DB[TB]> & string)[]",
"score": 0.898535966873169
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n QB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n > {\n return new SubsettingMappingInsertQuery(\n this.db,\n this.qb,\n columnsToInsert,",
"score": 0.8878589868545532
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " InsertedObject,\n InsertReturnColumns,\n InsertReturn\n > {\n return new AnyColumnsMappingInsertQuery(\n this.db,\n this.getInsertQB(),\n this.transforms,\n this.insertReturnColumns as InsertReturnColumns\n );",
"score": 0.8873348236083984
}
] |
typescript
|
const parameterizedValues = this.getParameterizedObject(columnsToInsert);
|
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { ParametersObject } from 'kysely-params';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for updating rows in a database table.
*/
export class CompilingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn,
Parameters extends ParametersObject<Parameters>
> extends CompilingValuesQuery<
DB,
TB,
QB,
UpdateReturnColumns,
Parameters,
Updateable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToUpdate);
this.qb = qb.set(parameterizedValues) as QB;
}
/**
* Runs the query, returning the number of rows updated, in the required
* client representation. Accepts values for any parameters embedded in
* the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns Number of rows updated, in client-requested representation.
*/
async returnCount(
params: Parameters,
obj: UpdatingObject
): Promise<ReturnCount> {
const transformedObj = this.applyUpdateTransform(obj);
const compiledQuery = this.
|
instantiateNoReturns(params, transformedObj);
|
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.countTransform === undefined
? (result.numAffectedRows as ReturnCount)
: this.transforms.countTransform(result.numAffectedRows!);
}
/**
* Updates rows with the values that result from transforming the object via
* `insertTransform` (if defined). For each row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an array containing one
* object for each row updated; otherwise returns `undefined`.
*/
returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;
async returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn[] | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.updateReturnTransform === undefined
? (result.rows as any)
: result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
);
}
/**
* Updates rows with the values that result from transforming the object via
* `updateTransform` (if defined). For the first row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is empty, returns `undefined`. Otherwise,
* returns the first object if at least one row was updated, or `null` if
* no rows were updated.
*/
returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;
async returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn | null | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
return null;
}
return this.applyUpdateReturnTransform(
obj as UpdatingObject,
result.rows[0] as any
);
}
/**
* Runs the query, updating rows, without returning any columns. Accepts
* values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns `true` if any rows were updated, `false` otherwise.
*/
async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {
return (await this.returnCount(params, obj)) !== 0;
}
protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {
return this.transforms.updateTransform === undefined
? (obj as Updateable<DB[TB]>)
: this.transforms.updateTransform(obj, this.columnsToUpdate);
}
protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {
return this.transforms.updateReturnTransform === undefined
? (returns as any)
: this.transforms.updateReturnTransform(source, returns);
}
}
|
src/queries/compiling-update-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " this.returnColumns\n );\n }\n /**\n * Runs the query, returning the number of rows updated, in\n * the required client representation.\n * @param obj The object which which to update the rows.\n * @returns Number of rows updated, in client-requested representation.\n */\n async returnCount(obj: UpdatingObject): Promise<ReturnCount> {",
"score": 0.9519017934799194
},
{
"filename": "src/queries/compiling-delete-query.ts",
"retrieved_chunk": " * @param params Record characterizing the parameter names and types.\n * Pass in `{}` if the query has no parameters.\n * @returns Number of rows deleted, in client-requested representation.\n */\n async returnCount(params: Parameters): Promise<ReturnCount> {\n const result = await this.#parameterizedQuery.execute(this.db, params);\n return this.transforms.countTransform === undefined\n ? (result.numAffectedRows! as ReturnCount)\n : this.transforms.countTransform(result.numAffectedRows!);\n }",
"score": 0.9019359946250916
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " /**\n * Runs the query, updating rows, without returning any columns.\n * @param obj The object which which to update the rows.\n * @returns `true` if any rows were updated, `false` otherwise.\n */\n async run(obj: UpdatingObject): Promise<boolean> {\n const results = await this.loadUpdatingObject(\n this.qb,\n obj\n ).executeTakeFirst();",
"score": 0.8743192553520203
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;\n async returnOne(obj: UpdatingObject): Promise<UpdateReturn | null | void> {\n if (this.returnColumns.length === 0) {\n await this.loadUpdatingObject(this.qb, obj as UpdatingObject).execute();\n return;\n }\n const returns = await this.loadUpdatingObject(\n this.getReturningQB(),\n obj as UpdatingObject\n ).execute();",
"score": 0.8576053977012634
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " async returnAll(obj: UpdatingObject): Promise<UpdateReturn[] | void> {\n if (this.returnColumns.length === 0) {\n await this.loadUpdatingObject(this.qb, obj as UpdatingObject).execute();\n return;\n }\n const returns = await this.loadUpdatingObject(\n this.getReturningQB(),\n obj as UpdatingObject\n ).execute();\n return this.transforms.updateReturnTransform === undefined",
"score": 0.8553398847579956
}
] |
typescript
|
instantiateNoReturns(params, transformedObj);
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
userObject1,
userRow1,
userRow2,
userRow3,
} from './utils/test-objects';
import { ReturnedUser, UpdatingUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating with transformation', () => {
it('transforms users for update without transforming return', async () => {
const mapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
});
const insertReturns = await mapper
.insert()
.returnAll([userRow1, userRow2, userRow3]);
const updatingUser1 = UpdatingUser.create(
0,
Object.assign({}, userObject1, { firstName: 'Suzanne' })
);
const updateReturns = await mapper
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updatingUser1);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
const readUsers = await mapper
.select()
.modify((qb) => qb.orderBy('id'))
.returnAll();
expect(readUsers).toEqual([
Object.assign({}, userRow1, {
id: insertReturns[0].id,
name: 'Suzanne Smith',
}),
Object.assign({}, userRow2, { id: insertReturns[1].id }),
Object.assign({}, userRow1, {
id: insertReturns[2].id,
name: 'Suzanne Smith',
}),
]);
});
it('transforms update return into object without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateReturnTransform: (source, returns) =>
new ReturnedUser(
returns.id,
source.name ? source.name.split(' ')[0] : '(first)',
source.name ? source.name.split(' ')[1] : '(last)',
source.handle ? source.handle : '(handle)',
source.email ? source.email : '(email)'
),
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smith',
'(handle)',
'(email)'
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn1[0].firstName);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smithy',
'(handle)',
'(email)'
)
);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn2!.firstName);
});
it('transforms update return into primitive without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
updateReturnTransform: (_source, returns) => returns.id,
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([1]);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn1[0]);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(1);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn2!);
});
it("transforms update and update return, columns is ['*']", async () => {
expect.assertions(2);
const updateAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (source: UpdatingUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
});
const insertReturn = await updateAndReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn = await updateAndReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll(UpdatingUser.create(0, userObject1));
expect(updateReturn).toEqual([
new ReturnedUser(
insertReturn.id,
userObject1.firstName,
userObject1.lastName,
userObject1.handle,
userObject1.email
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn[0].firstName);
});
it('transforms a union of updating object types', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser | Updateable<
|
Users>) =>
source instanceof UpdatingUser
? {
|
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}
: source,
});
const insertReturn = await mapper.insert().returnOne(userRow1);
// test with UpdatingUser
await mapper
.update({ id: insertReturn.id })
.columns(['name'])
.run(UpdatingUser.create(0, userObject1));
const readUser1 = await mapper.select(insertReturn.id).returnOne();
expect(readUser1).toEqual({
id: insertReturn.id,
name: `${userObject1.firstName} ${userObject1.lastName}`,
email: userRow1.email,
handle: userRow1.handle,
});
// test with Updateable<Users>
const newName = 'Suzanne Smith Something';
await mapper.update({ id: insertReturn.id }).run({ name: newName });
const readUser2 = await mapper.select(insertReturn.id).returnOne();
expect(readUser2).toEqual({
id: insertReturn.id,
name: newName,
email: userRow1.email,
handle: userRow1.handle,
});
});
});
|
src/tests/update-transform.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " it('parameterizes an update query with transformation', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({",
"score": 0.9196608066558838
},
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " });\n });\n ignore('detects invalid update return transform return', async () => {\n const mapper = new TableMapper(db, 'users', { keyColumns: ['id'] });\n mapper.withTransforms({\n selectTransform: (_user) => new User(1, 'John', 'Doe', 'jdoe', 'x@y.z'),\n updateTransform: (user: User) => ({\n id: user.id,\n name: `${user.firstName} ${user.lastName}`,\n handle: user.handle,",
"score": 0.9186829328536987
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " });\n it('transforms insertion return into object without transforming insertion', async () => {\n const insertReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id', 'name'],\n updateReturnColumns: ['id', 'name'],\n }).withTransforms({\n insertReturnTransform: (source, returns) => {\n const names = returns.name.split(' ');\n return new ReturnedUser(\n returns.id,",
"score": 0.9082643985748291
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " // test that updates return rows\n const updateReturn = await transformMapper\n .update({ id: 1 })\n .returnOne(expectedUser2);\n expect(updateReturn).toEqual({\n id: 1,\n name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,\n });\n // ensure return type can be accessed as a row\n ((_: string) => {})(updateReturn!.name);",
"score": 0.9058712720870972
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " it('returns SelectedObject with updates returning rows', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id', 'name'],\n updateReturnColumns: ['id', 'name'],\n }).withTransforms({\n insertReturnTransform: (source, results) => {\n const names = results.name.split(' ');\n return SelectedUser.create(results.id, {\n firstName: names[0],\n lastName: names[1],",
"score": 0.9057731032371521
}
] |
typescript
|
Users>) =>
source instanceof UpdatingUser
? {
|
import {
ComparisonOperatorExpression,
Kysely,
OperandValueExpressionOrList,
ReferenceExpression,
WhereInterface,
} from 'kysely';
import { SelectableColumnTuple } from './type-utils';
import { QueryFilter } from './query-filter';
type AnyWhereInterface = WhereInterface<any, any>;
/**
* Returns a query builder that constrains the provided query builder
* according to the provided query filter or binary operation.
* @param base The Kysely mapper that is used to create references.
* @param qb The query builder to constrain.
* @param filterOrLHS The query filter or left-hand side of a binary operation.
* @param op The operator of a binary operation.
* @param rhs The right-hand side of a binary operation.
* @returns A query builder constrained for the provided query filter
* or binary operation.
*/
export function applyQueryFilter<
DB,
TB extends keyof DB & string,
KeyColumns extends Readonly<SelectableColumnTuple<DB[TB]>> | Readonly<[]>,
QB extends AnyWhereInterface,
RE extends ReferenceExpression<DB, TB>
>(
db: Kysely<DB>,
qb: QB,
keyColumns: KeyColumns,
filterOrLHS: QueryFilter<DB, TB, KeyColumns, RE> | RE,
op?: ComparisonOperatorExpression,
rhs?: OperandValueExpressionOrList<DB, TB, RE>
): QB {
// Process a binary operation.
if (op !== undefined) {
return qb.where(filterOrLHS as RE, op, rhs!) as QB;
}
const filter = filterOrLHS as QueryFilter<DB, TB, KeyColumns, RE>;
if (typeof filter === 'object') {
// Process a key tuple filter.
if (Array.isArray(filter)) {
keyColumns.
|
forEach((column, i) => {
|
qb = qb.where(db.dynamic.ref(column), '=', filter[i]) as QB;
});
return qb;
}
// Process a query expression filter. Check for expressions
// first because they could potentially be plain objects.
if ('expressionType' in filter) {
return qb.where(filter) as QB;
}
// Process a field matching filter. `{}` matches all rows.
if (filter.constructor === Object) {
for (const [column, value] of Object.entries(filter)) {
if (Array.isArray(value)) {
qb = qb.where(db.dynamic.ref(column), 'in', value) as QB;
} else {
qb = qb.where(db.dynamic.ref(column), '=', value) as QB;
}
}
return qb as unknown as QB;
}
}
// Process a where expression factory.
if (typeof filter === 'function') {
return qb.where(filter as any) as QB;
}
// Process a single key filter, expressed as a primitive value.
if (keyColumns.length === 1) {
return qb.where(db.dynamic.ref(keyColumns[0]), '=', filter) as QB;
}
throw Error('Unrecognized query filter');
}
|
src/lib/apply-query-filter.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " : applyQueryFilter(\n this.db,\n this.getSelectQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms\n );",
"score": 0.8903175592422485
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " ? this.getDeleteQB()\n : applyQueryFilter(\n this.db,\n this.getDeleteQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms",
"score": 0.8763859868049622
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " this.db,\n this.getUpdateQB(),\n this.keyColumns,\n filterOrLHS,\n op,\n rhs\n ),\n this.transforms,\n this.updateReturnColumns as UpdateReturnColumns\n );",
"score": 0.8723795413970947
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " UpdateReturn\n >;\n update<RE extends ReferenceExpression<DB, TB>>(\n filterOrLHS?: QueryFilter<DB, TB, KeyColumns, RE> | RE,\n op?: ComparisonOperatorExpression,\n rhs?: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingUpdateQuery<\n DB,\n TB,\n UpdateQueryBuilder<DB, TB, TB, UpdateResult>,",
"score": 0.8640540242195129
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " TB,\n SelectedColumns,\n SelectedObject,\n SelectQueryBuilder<DB, TB, object>\n >;\n select<RE extends ReferenceExpression<DB, TB>>(\n filterOrLHS?: QueryFilter<DB, TB, KeyColumns, RE> | RE,\n op?: ComparisonOperatorExpression,\n rhs?: OperandValueExpressionOrList<DB, TB, RE>\n ): MappingSelectQuery<",
"score": 0.8464574217796326
}
] |
typescript
|
forEach((column, i) => {
|
import { Kysely, sql } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningIDAndHandleAsH,
createUserMapperReturningAll,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningIDAndHandleAsH: ReturnType<
typeof createUserMapperReturningIDAndHandleAsH
>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningIDAndHandleAsH =
createUserMapperReturningIDAndHandleAsH(db);
userMapperReturningAll = createUserMapperReturningAll(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('general update', () => {
it('updates nothing returning zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const success = await userMapperReturningAll
.update({ id: 1 })
.run(updateValues);
expect(success).toBe(false);
const updateCount = await userMapperReturningAll
.update({ id: 1 })
.returnCount(updateValues);
expect(updateCount).toEqual(0);
const updates = await userMapperReturningID
.update({ id: 1 })
.returnAll(updateValues);
expect(updates.length).toEqual(0);
const update = await userMapperReturningID
.update({ id: 1 })
.returnOne(updateValues);
expect(update).toBeNull();
});
it('updates something returning non-zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const insertReturn0 = await userMapperReturningID
.insert()
.returnOne(USERS[0]);
await userMapperReturningID.insert().run(USERS[1]);
await userMapperReturningID.insert().run(USERS[2]);
const updateCount1 = await userMapperReturningAll
.update({ id: insertReturn0.id })
.returnCount(updateValues);
expect(updateCount1).toEqual(1);
const readUser1 = await userMapperReturningID
.select('id', '=', insertReturn0.id)
.returnOne();
expect(readUser1?.email).toEqual(updateValues.email);
const updateCount2 = await userMapperReturningAll
.update({ name: 'Sue' })
.returnCount(updateValues);
expect(updateCount2).toEqual(2);
const readUsers = await userMapperReturningID
.select('name', '=', 'Sue')
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].email).toEqual(updateValues.email);
expect(readUsers[1].email).toEqual(updateValues.email);
const updates = await userMapperReturningID.update().returnAll({
name: 'Every User 1',
});
expect(updates).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
const update = await userMapperReturningID
.update({ id: readUsers[0].id })
.returnOne({
name: 'Every User 2',
});
expect(update).toEqual({ id: 1 });
const readUser2 = await userMapperReturningID
.select('id', '=', 1)
.returnOne();
expect(readUser2?.name).toEqual('Every User 2');
const updateCount = await userMapperReturningID.update().returnCount({
name: 'Every User 3',
});
expect(updateCount).toEqual(3);
const success = await userMapperReturningID.update().run({
name: 'Every User 4',
});
expect(success).toBe(true);
});
it('updates returning configured return columns', async () => {
await userMapperReturningID.insert().run(USERS[0]);
const insertReturn = await userMapperReturningID
.insert()
.returnOne(USERS[1]);
await userMapperReturningID.insert().run(USERS[2]);
// Verify that update performs the correct change on the correct row.
const updateValues1 = { email: 'new.email@xyz.pdq' };
const updateReturns1 = await userMapperReturningID
.update({ id: insertReturn.id })
.returnAll(updateValues1);
expect(updateReturns1).toEqual([{ id: insertReturn.id }]);
let readUser = await userMapperReturningID
.select('id', '=', insertReturn.id)
.returnOne();
expect(readUser?.email).toEqual(updateValues1.email);
// Verify a different change on the same row, returning multiple columns.
const updateValues2 = { name: 'Sue' };
const updateReturns2 = await userMapperReturningIDAndHandleAsH
.update({ email: updateValues1.email })
.returnAll(updateValues2);
updateReturns2[0].id; // ensure key is accessible
updateReturns2[0].h; // ensure key is accessible
expect(updateReturns2).toEqual([
{
id: insertReturn.id,
h: USERS[1].handle,
},
]);
readUser = await userMapperReturningID
.select('id', '=', insertReturn.id)
.returnOne();
expect(readUser?.name).toEqual(updateValues2.name);
// Verify that update changes all required rows.
const updateValues3 = { name: 'Replacement Sue' };
const updateReturns3 = await userMapperReturningIDAndHandleAsH
.update({ name: 'Sue' })
.returnAll(updateValues3);
expect(updateReturns3.length).toEqual(3);
expect(updateReturns3[0].h).toEqual(USERS[0].handle);
expect(updateReturns3[1].h).toEqual(USERS[1].handle);
expect(updateReturns3[2].h).toEqual(USERS[2].handle);
const readUsers = await userMapperReturningID
.select('name', '=', updateValues3.name)
.returnAll();
expect(readUsers.length).toEqual(3);
ignore('check return types', () => {
// @ts-expect-error - check return types
updateReturns2[0].title;
// @ts-expect-error - check return types
updateReturns2[0].userId;
});
});
it('update returns void when defaulting to no return columns', async () => {
await userMapperReturningID.insert().run(USERS);
const updates = await userMapperReturningDefault
.update({ name: 'Sue' })
.returnAll({ email: 'new.email@xyz.pdq' });
expect(updates).toBeUndefined();
const readUsers = await userMapperReturningID
.select({
email: 'new.email@xyz.pdq',
})
.returnAll();
expect(readUsers.length).toEqual(2);
});
it('update returns void when explicitly no return columns', async () => {
await userMapperReturningID.insert().run(USERS);
const updates = await userMapperReturningNothing
.update({ name: 'Sue' })
.returnAll({ email: 'new.email@xyz.pdq' });
expect(updates).toBeUndefined();
const readUsers = await userMapperReturningID
.select({
email: 'new.email@xyz.pdq',
})
.returnAll();
expect(readUsers.length).toEqual(2);
const update = await userMapperReturningNothing
.update({ name: 'Sue' })
.returnOne({ email: 'new2.email@xyz.pdq' });
expect(update).toBeUndefined();
const readUser = await userMapperReturningID
.select({
email: 'new2.email@xyz.pdq',
})
.returnOne();
expect(readUser!.id).toEqual(1);
ignore('type errors', () => {
// @ts-expect-error - check return types
updates[0].id;
// @ts-expect-error - check return types
update!.id;
});
});
it('updates configured to return all columns', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues1 = { email: 'new.email@xyz.pdq' };
const updateReturns = await userMapperReturningAll
.update({ name: 'Sue' })
.returnAll(updateValues1);
const expectedUsers = [
Object.assign({}, USERS[0], updateValues1, { id: insertReturns[0].id }),
Object.assign({}, USERS[2], updateValues1, { id: insertReturns[2].id }),
];
expect(updateReturns).toEqual(expectedUsers);
// Ensure that the returned value can be accessed as a row.
((_: string) => {})(updateReturns[0].name);
((_: string | null) => {})(updateReturns[0].email);
const updateValues2 = { email: 'another.email@xyz.pdq' };
const updateReturn = await userMapperReturningAll
.update({ name: 'Sue' })
.returnOne(updateValues2);
const expectedUser = Object.assign({}, USERS[0], updateValues2, {
id: insertReturns[0].id,
});
expect(updateReturn).toEqual(expectedUser);
// Ensure that the returned value can be accessed as a row.
((_: string) => {})(updateReturn!.name);
((_: string | null) => {})(updateReturn!.email);
});
it('updates all rows when no filter is given', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { email: 'new.email@xyz.pdq' };
const updateReturns = await userMapperReturningIDAndHandleAsH
.update()
.returnAll(updateValues);
const
|
expectedUsers = USERS.map((user, i) => ({
|
id: insertReturns[i].id,
h: user.handle,
}));
expect(updateReturns).toEqual(expectedUsers);
const readUsers = await userMapperReturningID.select().returnAll();
expect(readUsers.length).toEqual(3);
for (const user of readUsers) {
expect(user.email).toEqual(updateValues.email);
}
});
it('updates rows indicated by a binary operator', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { email: 'new.email@xyz.pdq' };
const updateCount = await userMapperReturningAll
.update('id', '>', insertReturns[0].id)
.returnCount(updateValues);
expect(updateCount).toEqual(2);
const readUsers = await userMapperReturningID
.select('id', '>', insertReturns[0].id)
.returnAll();
expect(readUsers.length).toEqual(2);
for (const user of readUsers) {
expect(user.email).toEqual(updateValues.email);
}
});
it('updates rows indicated by a kysely expression', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { email: 'new.email@xyz.pdq' };
const updateCount = await userMapperReturningDefault
.update(sql`id > ${insertReturns[0].id}`)
.returnCount(updateValues);
expect(updateCount).toEqual(BigInt(2));
const readUsers = await userMapperReturningID
.select('id', '>', insertReturns[0].id)
.returnAll();
expect(readUsers.length).toEqual(2);
for (const user of readUsers) {
expect(user.email).toEqual(updateValues.email);
}
});
it('updates rows indicated by a where expression filter', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues1 = { email: 'foo@xyz.pdq' };
const updateCount = await userMapperReturningAll
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnCount(updateValues1);
expect(updateCount).toEqual(2);
const updateValues2 = { email: 'bar@xyz.pdq' };
const updateReturns = await userMapperReturningID
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updateValues2);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
});
ignore('detects update type errors', async () => {
userMapperReturningID.update(
// @ts-expect-error - table must have all filter fields
{ notThere: 'xyz' }
);
// @ts-expect-error - table must have all filter fields
userMapperReturningID.update('notThere', '=', 'foo');
userMapperReturningID.update(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via anyOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
// @ts-expect-error - ID filter must have correct type
userMapperReturningID.update('str');
// @ts-expect-error - ID filter must have correct type
userMapperReturningID.update(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.update(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.update([1]);
userMapperReturningID.update({ id: 32 }).returnAll(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).returnAll(USERS[0]))[0].name;
userMapperReturningID.update({ id: 32 }).returnOne(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).returnOne(USERS[0]))[0].name;
userMapperReturningID.update({ id: 32 }).returnCount(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).returnCount(USERS[0]))[0].name;
userMapperReturningID.update({ id: 32 }).run(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).run(USERS[0]))[0].name;
});
});
|
src/tests/update-general.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " handle: USERS[0].handle,\n });\n });\n it('subsets updating columns, including ID', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const updateValues = { id: 100, name: 'Sue Rex', email: 'rex@abc.def' };\n const subsetQuery = userMapperReturningID\n .update('id', '=', insertReturns[0].id)\n .columns(['id', 'name', 'email']);\n const updateReturns = await subsetQuery.returnAll(updateValues);",
"score": 0.9129916429519653
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " // @ts-expect-error - check return types\n updateReturns[0].userId;\n });\n });\n it('inserts multiple returning no columns by default', async () => {\n const insertReturns = await userMapperReturningDefault\n .insert()\n .returnAll(USERS);\n expect(insertReturns).toBeUndefined();\n const readUsers = await userMapperReturningAll.select().returnAll();",
"score": 0.9096658229827881
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " );\n });\n });\n it('requires all indicated columns to be updated', async () => {\n await userMapperReturningID.insert().run(USERS);\n const compilation = userMapperReturningID\n .update()\n .columns(['name', 'handle', 'email'])\n .compile();\n const updateValues = { name: 'John Doe', handle: 'johndoe' };",
"score": 0.9087165594100952
},
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " });\n it('requires all subsetted columns to be updated', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const updateValues = { name: 'Sue Rex' };\n const subsetQuery = userMapperReturningID\n .update('id', '=', insertReturns[0].id)\n .columns(['name', 'email']);\n expect(() => subsetQuery.returnAll(updateValues)).rejects.toThrow(\n `column 'email' missing`\n );",
"score": 0.908198356628418
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " '(email)'\n ),\n ]);\n // Ensure the returned value is accessible as a ReturnedUser\n ((_: string) => {})(updateReturn1[0].firstName);\n const updateReturn2 = await updateReturnTransformMapper\n .update({ id: insertReturn.id })\n .returnOne({ name: 'Suzanne Smithy' });\n expect(updateReturn2).toEqual(\n new ReturnedUser(",
"score": 0.9072997570037842
}
] |
typescript
|
expectedUsers = USERS.map((user, i) => ({
|
import { Kysely, InsertQueryBuilder, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for inserting rows into a database table.
*/
export class CompilingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, any>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends CompilingValuesQuery<
DB,
TB,
QB,
InsertReturnColumns,
{},
Insertable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToInsert);
this.qb = qb.values(parameterizedValues) as QB;
}
/**
* Inserts the provided object into the table as a row, first transforming
* it into a row via `insertTransform` (if defined). Also retrieves the
* columns specified in `returnColumns`, returning them to the caller as
* `InsertReturn`, after transformation by `insertReturnTransform`.
* If `returnColumns` is empty, returns `undefined`.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an object;
* otherwise returns `undefined`.
*/
returnOne(
obj: InsertedObject
): Promise<InsertReturnColumns extends [] ? void : InsertReturn>;
async returnOne(obj: InsertedObject): Promise<InsertReturn | void> {
if (this.returnColumns.length === 0) {
await this.run(obj);
return;
}
const transformedObj = this.applyInsertTransform(obj);
const compiledQuery = this.instantiateWithReturns({}, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
throw Error(
'No row returned from compiled insert expecting returned columns'
);
}
return this.transforms.insertReturnTransform === undefined
? (result.rows[0] as any)
: this.transforms.insertReturnTransform(obj, result.rows[0] as any);
}
/**
* Runs the query, inserting rows into the table without returning any
* columns.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param objOrObjs The object or objects to be inserted.
* @returns Returns `true`; throws an exception on error.
*/
async run(obj: InsertedObject): Promise<boolean> {
const transformedObj = this.applyInsertTransform(obj);
|
const compiledQuery = this.instantiateNoReturns({}, transformedObj);
|
await this.db.executeQuery(compiledQuery);
return true;
}
protected applyInsertTransform(obj: InsertedObject): Insertable<DB[TB]> {
return this.transforms.insertTransform === undefined
? (obj as Insertable<DB[TB]>)
: this.transforms.insertTransform(obj, this.columnsToInsert);
}
}
|
src/queries/compiling-insert-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " * Runs the query, inserting rows into the table without returning any columns.\n * @param objOrObjs The object or objects to be inserted.\n * @returns Returns `true`; throws an exception on error.\n */\n async run(objOrObjs: InsertedObject | InsertedObject[]): Promise<boolean> {\n await this.loadInsertedObjects(this.qb, objOrObjs).execute();\n return true;\n }\n /**\n * Returns an array of the columns to be inserted, with",
"score": 0.8767798542976379
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " this.transforms.insertTransform === undefined\n ? (objOrObjs as Insertable<DB[TB]>[])\n : objOrObjs.map((obj) =>\n this.transforms.insertTransform!(obj, insertColumns)\n );\n // TS requires separate calls to values() for different arg types.\n return this.setColumnValues(qb, transformedObjs);\n }\n const transformedObj =\n this.transforms.insertTransform === undefined",
"score": 0.8725655674934387
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " * @param objOrObjs The object or objects to be inserted.\n * @returns The query builder with the objects loaded.\n */\n protected loadInsertedObjects(\n qb: InsertQueryBuilder<DB, TB, InsertResult>,\n objOrObjs: InsertedObject | InsertedObject[]\n ): InsertQueryBuilder<DB, TB, InsertResult> {\n const insertColumns = this.getInsertColumns();\n if (Array.isArray(objOrObjs)) {\n const transformedObjs =",
"score": 0.8721798658370972
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " if (this.returnColumns.length === 0) {\n await this.loadInsertedObjects(this.qb, objs).execute();\n return;\n }\n const returns = await this.loadInsertedObjects(\n this.getReturningQB(),\n objs\n ).execute();\n return this.transforms.insertReturnTransform === undefined\n ? (returns as any)",
"score": 0.8709698915481567
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " );\n }\n /**\n * Runs the query, updating rows, without returning any columns. Accepts\n * values for any parameters embedded in the query.\n *\n * On the first execution, compiles and discards the underlying Kysely\n * query builder. Subsequent executions reuse the compiled query.\n * @param obj The object which which to update the rows.\n * @returns `true` if any rows were updated, `false` otherwise.",
"score": 0.8665791749954224
}
] |
typescript
|
const compiledQuery = this.instantiateNoReturns({}, transformedObj);
|
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { MappingUpdateQuery } from './update-query';
import { SubsettingMappingUpdateQuery } from './subsetting-update-query';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Mapping query for updating rows from a database table, where the
* columns to be updated have not been restricted.
*/
export class AnyColumnsMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn
> extends MappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn
> {
constructor(
db: Kysely<DB>,
qb: QB,
transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a mapping query that only updates a specified subset of columns.
* @param columns The columns to update. All are required, but this
* constraint is only enforced at runtime, not by the type system.
* @returns A mapping query that only updates the specified columns.
*/
columns(
columnsToUpdate: Readonly<(keyof Updateable<DB[TB]> & string)[]>
): SubsettingMappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn
> {
return new SubsettingMappingUpdateQuery(
this.db,
this.
|
qb,
columnsToUpdate,
this.transforms,
this.returnColumns
);
|
}
}
|
src/queries/any-update-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn,\n Parameters\n > {\n return new CompilingMappingUpdateQuery(\n this.db,\n this.qb,\n this.columnsToUpdate,",
"score": 0.9002814292907715
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " NextQB,\n UpdatingObject,\n UpdateReturnColumns,\n ReturnCount,\n UpdateReturn\n > {\n return new MappingUpdateQuery(\n this.db,\n factory(this.qb),\n this.transforms,",
"score": 0.8952494263648987
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " InsertReturn,\n UpdateReturn,\n this,\n Parameters,\n SubsettingMappingUpdateQuery<\n DB,\n TB,\n UpdateQueryBuilder<DB, TB, TB, UpdateResult>,\n UpdatingObject,\n UpdateReturnColumns,",
"score": 0.8877302408218384
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " UpdateReturnColumns,\n UpdateReturn\n >\n >,\n returnColumns: Readonly<UpdateReturnColumns>\n ) {\n super(db, returnColumns);\n const parameterizedValues = this.getParameterizedObject(columnsToUpdate);\n this.qb = qb.set(parameterizedValues) as QB;\n }",
"score": 0.8805748224258423
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n QB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n > {\n return new SubsettingMappingInsertQuery(\n this.db,\n this.qb,\n columnsToInsert,",
"score": 0.8782856464385986
}
] |
typescript
|
qb,
columnsToUpdate,
this.transforms,
this.returnColumns
);
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
userObject1,
userRow1,
userRow2,
userRow3,
} from './utils/test-objects';
import { ReturnedUser, UpdatingUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating with transformation', () => {
it('transforms users for update without transforming return', async () => {
const mapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
});
const insertReturns = await mapper
.insert()
.returnAll([userRow1, userRow2, userRow3]);
const updatingUser1 = UpdatingUser.create(
0,
Object.assign({}, userObject1, { firstName: 'Suzanne' })
);
const updateReturns = await mapper
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updatingUser1);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
const readUsers = await mapper
.select()
.modify((qb) => qb.orderBy('id'))
.returnAll();
expect(readUsers).toEqual([
Object.assign({}, userRow1, {
id: insertReturns[0].id,
name: 'Suzanne Smith',
}),
Object.assign({}, userRow2, { id: insertReturns[1].id }),
Object.assign({}, userRow1, {
id: insertReturns[2].id,
name: 'Suzanne Smith',
}),
]);
});
it('transforms update return into object without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateReturnTransform: (source, returns) =>
new ReturnedUser(
returns.id,
source.name ? source.name.split(' ')[0] : '(first)',
source.name ? source.name.split(' ')[1] : '(last)',
source.handle ? source.handle : '(handle)',
source.email ? source.email : '(email)'
),
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smith',
'(handle)',
'(email)'
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn1[0].firstName);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smithy',
'(handle)',
'(email)'
)
);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn2!.firstName);
});
it('transforms update return into primitive without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (
|
_source, returns) => returns.id,
updateReturnTransform: (_source, returns) => returns.id,
});
|
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([1]);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn1[0]);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(1);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn2!);
});
it("transforms update and update return, columns is ['*']", async () => {
expect.assertions(2);
const updateAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (source: UpdatingUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
});
const insertReturn = await updateAndReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn = await updateAndReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll(UpdatingUser.create(0, userObject1));
expect(updateReturn).toEqual([
new ReturnedUser(
insertReturn.id,
userObject1.firstName,
userObject1.lastName,
userObject1.handle,
userObject1.email
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn[0].firstName);
});
it('transforms a union of updating object types', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser | Updateable<Users>) =>
source instanceof UpdatingUser
? {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}
: source,
});
const insertReturn = await mapper.insert().returnOne(userRow1);
// test with UpdatingUser
await mapper
.update({ id: insertReturn.id })
.columns(['name'])
.run(UpdatingUser.create(0, userObject1));
const readUser1 = await mapper.select(insertReturn.id).returnOne();
expect(readUser1).toEqual({
id: insertReturn.id,
name: `${userObject1.firstName} ${userObject1.lastName}`,
email: userRow1.email,
handle: userRow1.handle,
});
// test with Updateable<Users>
const newName = 'Suzanne Smith Something';
await mapper.update({ id: insertReturn.id }).run({ name: newName });
const readUser2 = await mapper.select(insertReturn.id).returnOne();
expect(readUser2).toEqual({
id: insertReturn.id,
name: newName,
email: userRow1.email,
handle: userRow1.handle,
});
});
});
|
src/tests/update-transform.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " });\n it('transforms insertion return into object without transforming insertion', async () => {\n const insertReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id', 'name'],\n updateReturnColumns: ['id', 'name'],\n }).withTransforms({\n insertReturnTransform: (source, returns) => {\n const names = returns.name.split(' ');\n return new ReturnedUser(\n returns.id,",
"score": 0.948491096496582
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });\n // ensure return type can be accessed as a row\n ((_: string) => {})(updatedUser!.name);\n });\n it('transforms insertion return into primitive without transforming insertion', async () => {\n const insertReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n insertReturnTransform: (_source, returns) => returns.id,\n countTransform: (count) => Number(count),",
"score": 0.9320472478866577
},
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " });\n });\n ignore('detects invalid update return transform return', async () => {\n const mapper = new TableMapper(db, 'users', { keyColumns: ['id'] });\n mapper.withTransforms({\n selectTransform: (_user) => new User(1, 'John', 'Doe', 'jdoe', 'x@y.z'),\n updateTransform: (user: User) => ({\n id: user.id,\n name: `${user.firstName} ${user.lastName}`,\n handle: user.handle,",
"score": 0.9291544556617737
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " it('returns SelectedObject with updates returning rows', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id', 'name'],\n updateReturnColumns: ['id', 'name'],\n }).withTransforms({\n insertReturnTransform: (source, results) => {\n const names = results.name.split(' ');\n return SelectedUser.create(results.id, {\n firstName: names[0],\n lastName: names[1],",
"score": 0.9217936992645264
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " it('parameterizes an update query with transformation', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({",
"score": 0.9210005402565002
}
] |
typescript
|
_source, returns) => returns.id,
updateReturnTransform: (_source, returns) => returns.id,
});
|
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningAll,
createUserMapperReturningDefault,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { TableMapper } from '../mappers/table-mapper';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningAll>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningAll(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('deleting rows via TableMapper', () => {
it('accepts readonly filters', async () => {
const filter = { name: 'Not There' as const } as const;
await userMapper.delete(filter).run();
await userMapper.delete(filter).returnCount();
});
it("doesn't delete anything if no rows match", async () => {
const count = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(0);
const success = await userMapper.delete({ name: USERS[0].name }).run();
expect(success).toEqual(false);
});
it('deletes rows without returning a count', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const success = await testMapper.delete({ name: USERS[0].name }).run();
expect(success).toBe(true);
const users = await testMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count as bigint default', async () => {
const defaultMapper = createUserMapperReturningDefault(db);
const count1 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(BigInt(0));
await defaultMapper.insert().run(USERS);
const count2 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(BigInt(2));
const users = await defaultMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count inferred as a number', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const count = await testMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(2);
});
it('deletes rows returning the deletion count as number', async () => {
const count1 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes all rows without a filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper.delete().returnCount();
expect(count1).toEqual(3);
const users1 = await userMapper.select().returnAll();
expect(users1.length).toEqual(0);
await userMapper.insert().run(USERS);
const success = await userMapper.delete().run();
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
});
it('deletes rows specified via compound filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete(({ and, cmpr }) =>
and([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count1).toEqual(1);
const count2 = await userMapper
.delete(({ or, cmpr }) =>
or([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count2).toEqual(1);
});
it('deletes rows specified via binary operation', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete('name', '=', USERS[0].name)
.returnCount();
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('modifies a delete query builder', async () => {
await userMapper.insert().run(USERS);
await userMapper.insert().run({ ...USERS[1], handle: 'user4' });
const count1 = await userMapper
.delete()
.modify((qb) => qb.where('name', '=', USERS[0].name))
.returnCount();
expect(count1).toEqual(2);
const count2 = await userMapper
.delete({ name: USERS[1].name })
.modify((qb) => qb.where('handle', '=', 'user4'))
.returnCount();
expect(count2).toEqual(1);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
});
it('compiles an unparameterized delete query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.delete({ name: USERS[0].name }).compile();
const count1 = await compilation.returnCount({});
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
await userMapper.insert().run(USERS[2]);
const success = await compilation.run({});
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(1);
expect(users2[0].handle).toEqual(USERS[1].handle);
});
it('parameterizes and compiles a delete query', async () => {
const parameterization = userMapper.parameterize<{ targetName: string }>(
|
({ mapper, param }) => mapper.delete({ name: param('targetName') })
);
|
const count1 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
const count3 = await parameterization.returnCount({
targetName: USERS[1].name,
});
expect(count3).toEqual(1);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.run({ notThere: 'foo' });
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.run({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.run({ targetName: 123 });
});
});
ignore('detects deletion type errors', async () => {
// @ts-expect-error - table must have all filter fields
userMapper.delete({ notThere: 'xyz' });
// @ts-expect-error - table must have all filter fields
userMapper.delete('notThere', '=', 'foo');
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via anyOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via allOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
// @ts-expect-error - ID filter must have correct type
userMapper.delete('str');
// @ts-expect-error - ID filter must have correct type
userMapper.delete(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete([1]);
});
});
|
src/tests/delete.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - errors on invalid column names\n users[0].notThere;\n // @ts-expect-error - errors on invalid column names\n user!.notThere;\n });\n });\n it('parameterizes and compiles a select query', async () => {\n await userMapper.insert().run(USERS);\n const parameterization = userMapper.parameterize<{ name: string }>(\n ({ mapper, param }) => mapper.select({ name: param('name') })",
"score": 0.9194517135620117
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " const success1 = await compilation.run(USERS[1]);\n expect(success1).toBe(true);\n // test returnOne()\n const success2 = await compilation.returnOne(USERS[2]);\n expect(success2).toBeUndefined();\n const readUsers = await userMapperReturningAll.select().returnAll();\n expect(readUsers.length).toEqual(2);\n expect(readUsers[0].handle).toEqual(USERS[1].handle);\n expect(readUsers[0].email).toEqual(null);\n expect(readUsers[1].handle).toEqual(USERS[2].handle);",
"score": 0.9102714657783508
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " expect(readUsers[1].email).toEqual(null);\n });\n it('compiles a returning insert query without transformation', async () => {\n const compilation = userMapperReturningAll\n .insert()\n .columns(['name', 'handle', 'email'])\n .compile();\n // test returnOne()\n const insertReturn = await compilation.returnOne(USERS[0]);\n expect(insertReturn).toEqual({ ...USERS[0], id: 1 });",
"score": 0.905181348323822
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " expect(readUser2).toEqual(expectedUser2);\n // test run()\n const success1 = await compilation.run({}, user1);\n expect(success1).toBe(true);\n const readUser3 = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser3).toEqual(expectedUser1);\n // test returnCount()\n const count = await compilation.returnCount({}, user2);",
"score": 0.9009833931922913
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " const updateValues1 = {\n name: 'Sue Rex' as const,\n email: 'srex@abc.def' as const,\n } as const;\n await compilation.run({}, updateValues1);\n });\n it('compiles a non-returning update query without transformation', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const compilation = userMapperReturningNothing\n .update('id', '=', insertReturns[0].id)",
"score": 0.899208664894104
}
] |
typescript
|
({ mapper, param }) => mapper.delete({ name: param('targetName') })
);
|
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { CompilingValuesQuery } from './compiling-values-query';
import { ParametersObject } from 'kysely-params';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
/**
* Compiling mapping query for updating rows in a database table.
*/
export class CompilingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn,
Parameters extends ParametersObject<Parameters>
> extends CompilingValuesQuery<
DB,
TB,
QB,
UpdateReturnColumns,
Parameters,
Updateable<DB[TB]>
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
protected readonly transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, returnColumns);
const parameterizedValues = this.getParameterizedObject(columnsToUpdate);
this.qb = qb.set(parameterizedValues) as QB;
}
/**
* Runs the query, returning the number of rows updated, in the required
* client representation. Accepts values for any parameters embedded in
* the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns Number of rows updated, in client-requested representation.
*/
async returnCount(
params: Parameters,
obj: UpdatingObject
): Promise<ReturnCount> {
const transformedObj = this.applyUpdateTransform(obj);
const compiledQuery = this.instantiateNoReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.countTransform === undefined
? (result.numAffectedRows as ReturnCount)
: this.transforms.countTransform(result.numAffectedRows!);
}
/**
* Updates rows with the values that result from transforming the object via
* `insertTransform` (if defined). For each row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is not empty, returns an array containing one
* object for each row updated; otherwise returns `undefined`.
*/
returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;
async returnAll(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn[] | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery =
|
this.instantiateWithReturns(params, transformedObj);
|
const result = await this.db.executeQuery(compiledQuery);
return this.transforms.updateReturnTransform === undefined
? (result.rows as any)
: result.rows.map((row) =>
this.applyUpdateReturnTransform(obj as UpdatingObject, row as any)
);
}
/**
* Updates rows with the values that result from transforming the object via
* `updateTransform` (if defined). For the first row updated, retrieves the
* columns specified in `returnColumns` (if defined), returning them to the
* caller as an `UpdateReturn`, after transformation by any provided
* `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.
* Accepts values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @returns If `returnColumns` is empty, returns `undefined`. Otherwise,
* returns the first object if at least one row was updated, or `null` if
* no rows were updated.
*/
returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;
async returnOne(
params: Parameters,
obj: UpdatingObject
): Promise<UpdateReturn | null | void> {
if (this.returnColumns.length === 0) {
await this.run(params, obj as UpdatingObject);
return;
}
const transformedObj = this.applyUpdateTransform(obj as UpdatingObject);
const compiledQuery = this.instantiateWithReturns(params, transformedObj);
const result = await this.db.executeQuery(compiledQuery);
if (result.rows.length === 0) {
return null;
}
return this.applyUpdateReturnTransform(
obj as UpdatingObject,
result.rows[0] as any
);
}
/**
* Runs the query, updating rows, without returning any columns. Accepts
* values for any parameters embedded in the query.
*
* On the first execution, compiles and discards the underlying Kysely
* query builder. Subsequent executions reuse the compiled query.
* @param obj The object which which to update the rows.
* @returns `true` if any rows were updated, `false` otherwise.
*/
async run(params: Parameters, obj: UpdatingObject): Promise<boolean> {
return (await this.returnCount(params, obj)) !== 0;
}
protected applyUpdateTransform(obj: UpdatingObject): Updateable<DB[TB]> {
return this.transforms.updateTransform === undefined
? (obj as Updateable<DB[TB]>)
: this.transforms.updateTransform(obj, this.columnsToUpdate);
}
protected applyUpdateReturnTransform(source: UpdatingObject, returns: any) {
return this.transforms.updateReturnTransform === undefined
? (returns as any)
: this.transforms.updateReturnTransform(source, returns);
}
}
|
src/queries/compiling-update-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn | null>;\n async returnOne(obj: UpdatingObject): Promise<UpdateReturn | null | void> {\n if (this.returnColumns.length === 0) {\n await this.loadUpdatingObject(this.qb, obj as UpdatingObject).execute();\n return;\n }\n const returns = await this.loadUpdatingObject(\n this.getReturningQB(),\n obj as UpdatingObject\n ).execute();",
"score": 0.9176472425460815
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " async returnAll(obj: UpdatingObject): Promise<UpdateReturn[] | void> {\n if (this.returnColumns.length === 0) {\n await this.loadUpdatingObject(this.qb, obj as UpdatingObject).execute();\n return;\n }\n const returns = await this.loadUpdatingObject(\n this.getReturningQB(),\n obj as UpdatingObject\n ).execute();\n return this.transforms.updateReturnTransform === undefined",
"score": 0.9167802333831787
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " * `updateTransform` (if defined). For each row updated, retrieves the\n * columns specified in `returnColumns` (if defined), returning them to the\n * caller as an `UpdateReturn`, after transformation by any provided\n * `updateReturnTransform`. If `returnColumns` is empty, returns `undefined`.\n * @returns If `returnColumns` is not empty, returns an array containing one\n * object for each row updated; otherwise returns `undefined`.\n */\n returnAll(\n obj: UpdatingObject\n ): Promise<UpdateReturnColumns extends [] ? void : UpdateReturn[]>;",
"score": 0.8835894465446472
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " /**\n * Runs the query, updating rows, without returning any columns.\n * @param obj The object which which to update the rows.\n * @returns `true` if any rows were updated, `false` otherwise.\n */\n async run(obj: UpdatingObject): Promise<boolean> {\n const results = await this.loadUpdatingObject(\n this.qb,\n obj\n ).executeTakeFirst();",
"score": 0.8809082508087158
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " this.returnColumns\n );\n }\n /**\n * Runs the query, returning the number of rows updated, in\n * the required client representation.\n * @param obj The object which which to update the rows.\n * @returns Number of rows updated, in client-requested representation.\n */\n async returnCount(obj: UpdatingObject): Promise<ReturnCount> {",
"score": 0.87950599193573
}
] |
typescript
|
this.instantiateWithReturns(params, transformedObj);
|
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningAll,
createUserMapperReturningDefault,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { TableMapper } from '../mappers/table-mapper';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningAll>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningAll(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('deleting rows via TableMapper', () => {
it('accepts readonly filters', async () => {
const filter = { name: 'Not There' as const } as const;
await userMapper.delete(filter).run();
await userMapper.delete(filter).returnCount();
});
it("doesn't delete anything if no rows match", async () => {
const count = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(0);
const success = await userMapper.delete({ name: USERS[0].name }).run();
expect(success).toEqual(false);
});
it('deletes rows without returning a count', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const success = await testMapper.delete({ name: USERS[0].name }).run();
expect(success).toBe(true);
const users = await testMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count as bigint default', async () => {
const defaultMapper = createUserMapperReturningDefault(db);
const count1 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(BigInt(0));
await defaultMapper.insert().run(USERS);
const count2 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(BigInt(2));
const users = await defaultMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count inferred as a number', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const count = await testMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(2);
});
it('deletes rows returning the deletion count as number', async () => {
const count1 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes all rows without a filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper.delete().returnCount();
expect(count1).toEqual(3);
const users1 = await userMapper.select().returnAll();
expect(users1.length).toEqual(0);
await userMapper.insert().run(USERS);
const success = await userMapper.delete().run();
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
});
it('deletes rows specified via compound filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete(({ and, cmpr }) =>
and([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count1).toEqual(1);
const count2 = await userMapper
.delete(({ or, cmpr }) =>
or([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count2).toEqual(1);
});
it('deletes rows specified via binary operation', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete('name', '=', USERS[0].name)
.returnCount();
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('modifies a delete query builder', async () => {
await userMapper.insert().run(USERS);
await userMapper.insert().run({ ...USERS[1], handle: 'user4' });
const count1 = await userMapper
.delete()
.modify((qb) => qb.where('name', '=', USERS[0].name))
.returnCount();
expect(count1).toEqual(2);
const count2 = await userMapper
.delete({ name: USERS[1].name })
.modify((qb) => qb.where('handle', '=', 'user4'))
.returnCount();
expect(count2).toEqual(1);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
});
it('compiles an unparameterized delete query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.delete({ name: USERS[0].name }).compile();
const count1 = await compilation.returnCount({});
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
|
await userMapper.insert().run(USERS[2]);
|
const success = await compilation.run({});
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(1);
expect(users2[0].handle).toEqual(USERS[1].handle);
});
it('parameterizes and compiles a delete query', async () => {
const parameterization = userMapper.parameterize<{ targetName: string }>(
({ mapper, param }) => mapper.delete({ name: param('targetName') })
);
const count1 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
const count3 = await parameterization.returnCount({
targetName: USERS[1].name,
});
expect(count3).toEqual(1);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.run({ notThere: 'foo' });
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.run({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.run({ targetName: 123 });
});
});
ignore('detects deletion type errors', async () => {
// @ts-expect-error - table must have all filter fields
userMapper.delete({ notThere: 'xyz' });
// @ts-expect-error - table must have all filter fields
userMapper.delete('notThere', '=', 'foo');
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via anyOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via allOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
// @ts-expect-error - ID filter must have correct type
userMapper.delete('str');
// @ts-expect-error - ID filter must have correct type
userMapper.delete(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete([1]);
});
});
|
src/tests/delete.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " expect(readUsers[1].email).toEqual(null);\n });\n it('compiles a returning insert query without transformation', async () => {\n const compilation = userMapperReturningAll\n .insert()\n .columns(['name', 'handle', 'email'])\n .compile();\n // test returnOne()\n const insertReturn = await compilation.returnOne(USERS[0]);\n expect(insertReturn).toEqual({ ...USERS[0], id: 1 });",
"score": 0.9196255803108215
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " userMapper = createUserMapperReturningID(db);\n userMapperReturningNothing = createUserMapperReturningNothing(db);\n});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('general selection', () => {\n it('compiles an unparameterized select query', async () => {\n await userMapper.insert().run(USERS);\n const compilation = userMapper.select({ name: USERS[0].name }).compile();\n const users = await compilation.returnAll({});",
"score": 0.9155108332633972
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " // test deleting a user\n const deleted = await userMapper\n .delete({ id: insertReturn.serialNo })\n .run();\n expect(deleted).toEqual(true);\n const selectedUser3 = await userMapper\n .select({ id: insertReturn.serialNo })\n .returnOne();\n expect(selectedUser3).toBeNull();\n });",
"score": 0.9149478673934937
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " await userMapper.insert().run(USERS);\n // Test selecting by condition (with results)\n let users = await userMapper.select('name', '=', USERS[0].name).returnAll();\n expect(users.length).toEqual(2);\n expect(users[0].handle).toEqual(USERS[0].handle);\n expect(users[1].handle).toEqual(USERS[2].handle);\n // Test selecting by condition (no results)\n users = await userMapper.select('name', '=', 'nonexistent').returnAll();\n expect(users.length).toEqual(0);\n });",
"score": 0.9126490950584412
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " // @ts-expect-error - errors on invalid column names\n users[0].notThere;\n // @ts-expect-error - errors on invalid column names\n user!.notThere;\n });\n });\n it('parameterizes and compiles a select query', async () => {\n await userMapper.insert().run(USERS);\n const parameterization = userMapper.parameterize<{ name: string }>(\n ({ mapper, param }) => mapper.select({ name: param('name') })",
"score": 0.9101013541221619
}
] |
typescript
|
await userMapper.insert().run(USERS[2]);
|
import { Insertable } from 'kysely';
import { Users, Posts } from './test-tables';
import { InsertedUser, ReturnedUser, SelectedUser } from './test-types';
export const USERS: Insertable<Users>[] = [
{
handle: 'handle1',
name: 'Sue',
email: 'foo1@bar.com',
},
{
handle: 'handle2',
name: 'Fred',
email: 'foo2@bar.com',
},
{
handle: 'handle3',
name: 'Sue',
email: 'foo3@bar.com',
},
];
export const POSTS: Insertable<Posts>[] = [
{
userId: 0,
title: 'About Something',
likeCount: 0,
},
{
userId: 0,
title: 'And Another Thing',
likeCount: 10,
},
{
userId: 0,
title: 'Still One More Thing',
likeCount: 1000,
},
];
export const userRow1 = {
name: 'John Smith',
handle: 'jsmith',
email: 'jsmith@xyz.pdq',
};
export const userRow2 = {
name: 'Jane Doe',
handle: 'jdoe',
email: 'jdoe@xyz.pdq',
};
export const userRow3 = {
name: 'Mary Sue',
handle: 'msue',
email: 'msue@xyz.pdq',
};
export const userObject1 = {
firstName: 'John',
lastName: 'Smith',
handle: userRow1.handle,
email: userRow1.email,
};
export const userObject2 = {
firstName: 'Jane',
lastName: 'Doe',
handle: userRow2.handle,
email: userRow2.email,
};
export const userObject3 = {
firstName: 'Mary',
lastName: 'Sue',
handle: userRow3.handle,
email: userRow3.email,
};
export const selectedUser1 = SelectedUser.create(1, userObject1);
export const selectedUser2 = SelectedUser.create(2, userObject2);
export const selectedUser3 = SelectedUser.create(3, userObject3);
export const insertedUser1 = InsertedUser.create(0, userObject1);
export const insertedUser2 = InsertedUser.create(0, userObject2);
export const insertedUser3 = InsertedUser.create(0, userObject3);
|
export const insertReturnedUser1 = ReturnedUser.create(1, userObject1);
|
export const insertReturnedUser2 = ReturnedUser.create(2, userObject2);
export const insertReturnedUser3 = ReturnedUser.create(3, userObject3);
|
src/tests/utils/test-objects.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names[1],\n handle: row.handle,\n email: row.email,\n });\n },\n });\n // test returnOne()\n const names1 = userRow1.name.split(' ');\n const expectedUser1 = SelectedUser.create(1, {\n firstName: names1[0],",
"score": 0.9038447141647339
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " id: insertReturn.id,\n })\n .returnOne();\n expect(readUser).toEqual(expectedUser1);\n // test returnAll()\n const names2 = userRow2.name.split(' ');\n const expectedUser2 = SelectedUser.create(2, {\n firstName: names2[0],\n lastName: names2[1],\n handle: userRow2.handle,",
"score": 0.8991515040397644
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " email: userRow2.email,\n });\n const names3 = userRow3.name.split(' ');\n const expectedUser3 = SelectedUser.create(3, {\n firstName: names3[0],\n lastName: names3[1],\n handle: userRow3.handle,\n email: userRow3.email,\n });\n const insertReturns = await transformMapper",
"score": 0.8966984748840332
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names1[1],\n handle: userRow1.handle,\n email: userRow1.email,\n });\n const insertReturn = await transformMapper.insert().returnOne(userRow1);\n expect(insertReturn).toEqual(expectedUser1);\n // ensure return type can be accessed as a SelectedUser\n ((_: string) => {})(insertReturn.firstName);\n const readUser = await transformMapper\n .select({",
"score": 0.8895302414894104
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " .select({ id: insertReturn1.id })\n .returnOne();\n expect(selectedUser4).toEqual(updatingUser2);\n // test updating multiple users returning rows\n const updatingUser3 = new MappedUser(\n selectedUser1!.id,\n 'Everyone',\n selectedUser1!.handle,\n selectedUser1!.email\n );",
"score": 0.8781833052635193
}
] |
typescript
|
export const insertReturnedUser1 = ReturnedUser.create(1, userObject1);
|
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningAll,
createUserMapperReturningDefault,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { TableMapper } from '../mappers/table-mapper';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningAll>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningAll(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('deleting rows via TableMapper', () => {
it('accepts readonly filters', async () => {
const filter = { name: 'Not There' as const } as const;
await userMapper.delete(filter).run();
await userMapper.delete(filter).returnCount();
});
it("doesn't delete anything if no rows match", async () => {
const count = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(0);
const success = await userMapper.delete({ name: USERS[0].name }).run();
expect(success).toEqual(false);
});
it('deletes rows without returning a count', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const success = await testMapper.delete({ name: USERS[0].name }).run();
expect(success).toBe(true);
const users = await testMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count as bigint default', async () => {
const defaultMapper = createUserMapperReturningDefault(db);
const count1 = await defaultMapper
|
.delete({ name: USERS[0].name })
.returnCount();
|
expect(count1).toEqual(BigInt(0));
await defaultMapper.insert().run(USERS);
const count2 = await defaultMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(BigInt(2));
const users = await defaultMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes rows returning the deletion count inferred as a number', async () => {
const testMapper = new TableMapper(db, 'users').withTransforms({
countTransform: (count) => Number(count),
});
await testMapper.insert().run(USERS);
const count = await testMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count).toEqual(2);
});
it('deletes rows returning the deletion count as number', async () => {
const count1 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await userMapper
.delete({ name: USERS[0].name })
.returnCount();
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('deletes all rows without a filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper.delete().returnCount();
expect(count1).toEqual(3);
const users1 = await userMapper.select().returnAll();
expect(users1.length).toEqual(0);
await userMapper.insert().run(USERS);
const success = await userMapper.delete().run();
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
});
it('deletes rows specified via compound filter', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete(({ and, cmpr }) =>
and([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count1).toEqual(1);
const count2 = await userMapper
.delete(({ or, cmpr }) =>
or([
cmpr('name', '=', USERS[0].name),
cmpr('handle', '=', USERS[0].handle),
])
)
.returnCount();
expect(count2).toEqual(1);
});
it('deletes rows specified via binary operation', async () => {
await userMapper.insert().run(USERS);
const count1 = await userMapper
.delete('name', '=', USERS[0].name)
.returnCount();
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
});
it('modifies a delete query builder', async () => {
await userMapper.insert().run(USERS);
await userMapper.insert().run({ ...USERS[1], handle: 'user4' });
const count1 = await userMapper
.delete()
.modify((qb) => qb.where('name', '=', USERS[0].name))
.returnCount();
expect(count1).toEqual(2);
const count2 = await userMapper
.delete({ name: USERS[1].name })
.modify((qb) => qb.where('handle', '=', 'user4'))
.returnCount();
expect(count2).toEqual(1);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
});
it('compiles an unparameterized delete query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.delete({ name: USERS[0].name }).compile();
const count1 = await compilation.returnCount({});
expect(count1).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
await userMapper.insert().run(USERS[2]);
const success = await compilation.run({});
expect(success).toBe(true);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(1);
expect(users2[0].handle).toEqual(USERS[1].handle);
});
it('parameterizes and compiles a delete query', async () => {
const parameterization = userMapper.parameterize<{ targetName: string }>(
({ mapper, param }) => mapper.delete({ name: param('targetName') })
);
const count1 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count1).toEqual(0);
await userMapper.insert().run(USERS);
const count2 = await parameterization.returnCount({
targetName: USERS[0].name,
});
expect(count2).toEqual(2);
const users = await userMapper.select().returnAll();
expect(users.length).toEqual(1);
expect(users[0].handle).toEqual(USERS[1].handle);
const count3 = await parameterization.returnCount({
targetName: USERS[1].name,
});
expect(count3).toEqual(1);
const users2 = await userMapper.select().returnAll();
expect(users2.length).toEqual(0);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.run({ notThere: 'foo' });
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.run({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.run({ targetName: 123 });
});
});
ignore('detects deletion type errors', async () => {
// @ts-expect-error - table must have all filter fields
userMapper.delete({ notThere: 'xyz' });
// @ts-expect-error - table must have all filter fields
userMapper.delete('notThere', '=', 'foo');
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via anyOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
userMapper.delete(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via allOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
// @ts-expect-error - ID filter must have correct type
userMapper.delete('str');
// @ts-expect-error - ID filter must have correct type
userMapper.delete(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.delete([1]);
});
});
|
src/tests/delete.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " expect(success).toBe(true);\n const readUsers = await userMapperReturningAll.select().returnAll();\n expect(readUsers.length).toEqual(3);\n for (let i = 0; i < USERS.length; i++) {\n expect(readUsers[i].handle).toEqual(USERS[i].handle);\n }\n ignore(\"can't access columns when returning nothing\", () => {\n // @ts-expect-error - can't access columns when returning nothing\n result.id;\n // @ts-expect-error - can't access columns when returning nothing",
"score": 0.9228041768074036
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users.length).toEqual(0);\n });\n it('selects all rows with no filter', async () => {\n await userMapper.insert().run(USERS);\n // Test selecting all\n const users = await userMapper.select().returnAll();\n expect(users.length).toEqual(USERS.length);\n for (let i = 0; i < USERS.length; i++) {\n expect(users[i].handle).toEqual(USERS[i].handle);\n }",
"score": 0.9191439151763916
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " const readUsers = await userMapperReturningAll.select().returnAll();\n expect(readUsers.length).toEqual(3);\n for (let i = 0; i < USERS.length; i++) {\n expect(readUsers[i].handle).toEqual(USERS[i].handle);\n }\n ignore(\"can't access columns when returning nothing\", () => {\n // @ts-expect-error - can't access columns when returning nothing\n insertReturns[0].id;\n });\n });",
"score": 0.9184043407440186
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " result[0].id;\n });\n });\n it('inserts multiple via returnAll() without returning columns', async () => {\n const results = await userMapperReturningDefault.insert().returnAll(USERS);\n expect(results).toBeUndefined();\n const readUsers = await userMapperReturningAll.select().returnAll();\n expect(readUsers.length).toEqual(3);\n for (let i = 0; i < USERS.length; i++) {\n expect(readUsers[i].handle).toEqual(USERS[i].handle);",
"score": 0.9165799617767334
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " await userMapper.insert().run(USERS);\n // Test selecting by condition (with results)\n let users = await userMapper.select('name', '=', USERS[0].name).returnAll();\n expect(users.length).toEqual(2);\n expect(users[0].handle).toEqual(USERS[0].handle);\n expect(users[1].handle).toEqual(USERS[2].handle);\n // Test selecting by condition (no results)\n users = await userMapper.select('name', '=', 'nonexistent').returnAll();\n expect(users.length).toEqual(0);\n });",
"score": 0.9148406982421875
}
] |
typescript
|
.delete({ name: USERS[0].name })
.returnCount();
|
import { Kysely, UpdateQueryBuilder, UpdateResult, Updateable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { MappingUpdateQuery } from './update-query';
import { ParameterizableMappingQuery } from './parameterizable-query';
import { ParametersObject } from 'kysely-params';
import { CompilingMappingUpdateQuery } from './compiling-update-query';
import {
CountTransform,
UpdateTransforms,
} from '../mappers/table-mapper-transforms';
import { restrictValues } from '../lib/restrict-values';
/**
* Mapping query for updating rows into a database table,
* updating a specified subset of the updateable columns.
*/
export class SubsettingMappingUpdateQuery<
DB,
TB extends keyof DB & string,
QB extends UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
UpdatingObject,
UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
ReturnCount,
UpdateReturn
>
extends MappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn
>
implements ParameterizableMappingQuery
{
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToUpdate: Readonly<
(keyof Updateable<DB[TB]> & string)[]
>,
transforms: Readonly<
CountTransform<ReturnCount> &
UpdateTransforms<
DB,
TB,
UpdatingObject,
UpdateReturnColumns,
UpdateReturn
>
>,
returnColumns: Readonly<UpdateReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a compiling query that can be executed multiple times with
* different parameters (if any parameters were provided), but which only
* compiles the underlying Kysely query builder on the first execution.
* Frees the query builder on the first execution to reduce memory usage.
* @typeParam Parameters Record characterizing the parameter names and
* types that were previously embedded in the query, if any.
* @returns A compiling update query.
*/
compile<
Parameters extends ParametersObject<Parameters> = {}
>(): CompilingMappingUpdateQuery<
DB,
TB,
QB,
UpdatingObject,
UpdateReturnColumns,
ReturnCount,
UpdateReturn,
Parameters
> {
return new CompilingMappingUpdateQuery(
this.db,
this.qb,
this.columnsToUpdate,
this.transforms,
this.returnColumns
);
}
protected override getUpdateColumns():
| Readonly<(keyof Updateable<DB[TB]> & string)[]>
| ['*'] {
return this.columnsToUpdate;
}
protected override setColumnValues(
qb: UpdateQueryBuilder<DB, TB, TB, UpdateResult>,
obj: Updateable<DB[TB]>
): UpdateQueryBuilder<DB, TB, TB, UpdateResult> {
return qb.
|
set(restrictValues(obj, this.columnsToUpdate));
|
}
}
|
src/queries/subsetting-update-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/queries/subsetting-insert-query.ts",
"retrieved_chunk": " | Readonly<(keyof Insertable<DB[TB]> & string)[]>\n | ['*'] {\n return this.columnsToInsert;\n }\n protected override setColumnValues(\n qb: InsertQueryBuilder<DB, TB, InsertResult>,\n objOrObjs: Insertable<DB[TB]> | Insertable<DB[TB]>[]\n ): InsertQueryBuilder<DB, TB, InsertResult> {\n if (Array.isArray(objOrObjs)) {\n return qb.values(",
"score": 0.9255027174949646
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " * @param qb The query builder to set the values into.\n * @param obj The object of column-value pairs to be updated.\n */\n protected setColumnValues(\n qb: UpdateQueryBuilder<DB, TB, TB, UpdateResult>,\n obj: Updateable<DB[TB]>\n ): UpdateQueryBuilder<DB, TB, TB, UpdateResult> {\n return qb.set(obj);\n }\n}",
"score": 0.9194502234458923
},
{
"filename": "src/queries/update-query.ts",
"retrieved_chunk": " ): UpdateQueryBuilder<DB, TB, TB, UpdateResult> {\n const updateColumns = this.getUpdateColumns();\n const transformedObj =\n this.transforms.updateTransform === undefined\n ? (obj as Updateable<DB[TB]>)\n : this.transforms.updateTransform(obj, updateColumns);\n return this.setColumnValues(qb, transformedObj);\n }\n /**\n * Sets the values of the updated columns.",
"score": 0.9129172563552856
},
{
"filename": "src/queries/insert-query.ts",
"retrieved_chunk": " */\n protected setColumnValues(\n qb: InsertQueryBuilder<DB, TB, InsertResult>,\n objOrObjs: Insertable<DB[TB]> | Insertable<DB[TB]>[]\n ): InsertQueryBuilder<DB, TB, InsertResult> {\n return qb.values(objOrObjs);\n }\n}",
"score": 0.902035117149353
},
{
"filename": "src/queries/compiling-update-query.ts",
"retrieved_chunk": " UpdateReturnColumns,\n UpdateReturn\n >\n >,\n returnColumns: Readonly<UpdateReturnColumns>\n ) {\n super(db, returnColumns);\n const parameterizedValues = this.getParameterizedObject(columnsToUpdate);\n this.qb = qb.set(parameterizedValues) as QB;\n }",
"score": 0.8783265948295593
}
] |
typescript
|
set(restrictValues(obj, this.columnsToUpdate));
|
import { Kysely, InsertQueryBuilder, InsertResult, Insertable } from 'kysely';
import { SelectionColumn } from '../lib/type-utils';
import { MappingInsertQuery } from './insert-query';
import { CompilingMappingInsertQuery } from './compiling-insert-query';
import { InsertTransforms } from '../mappers/table-mapper-transforms';
import { restrictValues } from '../lib/restrict-values';
/**
* Mapping query for inserting rows into a database table,
* inserting a specified subset of the insertable columns.
*/
export class SubsettingMappingInsertQuery<
DB,
TB extends keyof DB & string,
QB extends InsertQueryBuilder<DB, TB, InsertResult>,
InsertedObject,
InsertReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'],
InsertReturn
> extends MappingInsertQuery<
DB,
TB,
QB,
InsertedObject,
InsertReturnColumns,
InsertReturn
> {
constructor(
db: Kysely<DB>,
qb: QB,
protected readonly columnsToInsert: Readonly<
(keyof Insertable<DB[TB]> & string)[]
>,
transforms: Readonly<
InsertTransforms<
DB,
TB,
InsertedObject,
InsertReturnColumns,
InsertReturn
>
>,
returnColumns: Readonly<InsertReturnColumns>
) {
super(db, qb, transforms, returnColumns);
}
/**
* Returns a compiling query that can be executed multiple times with
* different parameters (if any parameters were provided), but which only
* compiles the underlying Kysely query builder on the first execution.
* Frees the query builder on the first execution to reduce memory usage.
* @typeParam Parameters Record characterizing the parameter names and
* types that were previously embedded in the query, if any.
* @returns A compiling insert query.
*/
compile(): CompilingMappingInsertQuery<
DB,
TB,
QB,
InsertedObject,
InsertReturnColumns,
InsertReturn
> {
return new CompilingMappingInsertQuery(
this.db,
this.qb,
this.columnsToInsert,
this.transforms,
this.returnColumns
);
}
protected
|
override getInsertColumns():
| Readonly<(keyof Insertable<DB[TB]> & string)[]>
| ['*'] {
|
return this.columnsToInsert;
}
protected override setColumnValues(
qb: InsertQueryBuilder<DB, TB, InsertResult>,
objOrObjs: Insertable<DB[TB]> | Insertable<DB[TB]>[]
): InsertQueryBuilder<DB, TB, InsertResult> {
if (Array.isArray(objOrObjs)) {
return qb.values(
objOrObjs.map((obj) => restrictValues(obj, this.columnsToInsert))
);
}
return qb.values(restrictValues(objOrObjs, this.columnsToInsert));
}
}
|
src/queries/subsetting-insert-query.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " #baseInsertQB: InsertQueryBuilder<DB, TB, InsertResult> | null = null;\n #baseSelectQB: SelectQueryBuilder<DB, TB, object> | null = null;\n #baseUpdateQB: UpdateQueryBuilder<DB, TB, TB, UpdateResult> | null = null;\n /** Columns that compose the table's primary key. */\n protected readonly keyColumns: KeyColumns;\n /** Columns to return from selection queries. `[]` => all columns. */\n protected readonly selectedColumns: SelectionColumn<DB, TB>[];\n /** Columns to return from the table on insert. */\n protected readonly insertReturnColumns:\n | Readonly<SelectionColumn<DB, TB>[]>",
"score": 0.883084774017334
},
{
"filename": "src/queries/any-insert-query.ts",
"retrieved_chunk": " TB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n >\n >,\n returnColumns: Readonly<InsertReturnColumns>\n ) {\n super(db, qb, transforms, returnColumns);\n }",
"score": 0.882886528968811
},
{
"filename": "src/queries/subsetting-update-query.ts",
"retrieved_chunk": " this.transforms,\n this.returnColumns\n );\n }\n protected override getUpdateColumns():\n | Readonly<(keyof Updateable<DB[TB]> & string)[]>\n | ['*'] {\n return this.columnsToUpdate;\n }\n protected override setColumnValues(",
"score": 0.8826925158500671
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " | ['*'] = Readonly<KeyColumns>,\n UpdateReturnColumns extends Readonly<SelectionColumn<DB, TB>[]> | ['*'] = [],\n InsertReturn = InsertReturnColumns extends ['*']\n ? Selectable<DB[TB]>\n : Selection<DB, TB, InsertReturnColumns[number]>,\n UpdateReturn = UpdateReturnColumns extends ['*']\n ? Selectable<DB[TB]>\n : Selection<DB, TB, UpdateReturnColumns[number]>\n> {\n #baseDeleteQB: DeleteQueryBuilder<DB, TB, DeleteResult> | null = null;",
"score": 0.8682253360748291
},
{
"filename": "src/queries/compiling-insert-query.ts",
"retrieved_chunk": " DB,\n TB,\n InsertedObject,\n InsertReturnColumns,\n InsertReturn\n >\n >,\n returnColumns: Readonly<InsertReturnColumns>\n ) {\n super(db, returnColumns);",
"score": 0.8671399354934692
}
] |
typescript
|
override getInsertColumns():
| Readonly<(keyof Insertable<DB[TB]> & string)[]>
| ['*'] {
|
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Posts } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningAll,
createUserMapperReturningNothing,
createUserMapperReturningDifferently,
} from './utils/test-mappers';
import { USERS, POSTS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
let postTableMapperReturningIDAndTitleAsT: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['id', 'title as t']
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningAll = createUserMapperReturningAll(db);
postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {
insertReturnColumns: ['id', 'title as t'],
}).withTransforms({
countTransform: (count) => Number(count),
});
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting an array of objects without transformation', () => {
it('inserts readonly objects', async () => {
const obj = {
name: 'John Doe' as const,
handle: 'johndoe' as const,
email: 'abc@def.ghi' as const,
} as const;
await userMapperReturningAll.insert().run(obj);
await userMapperReturningAll.insert().returnAll([obj]);
await userMapperReturningAll.insert().returnOne(obj);
});
it('inserts multiple via run() without returning columns', async () => {
|
const success = await userMapperReturningDefault.insert().run(USERS);
|
expect(success).toBe(true);
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
result.id;
// @ts-expect-error - can't access columns when returning nothing
result[0].id;
});
});
it('inserts multiple via returnAll() without returning columns', async () => {
const results = await userMapperReturningDefault.insert().returnAll(USERS);
expect(results).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
results.id;
// @ts-expect-error - can't access columns when returning nothing
results[0].id;
});
});
it('inserts multiple via returnOne() without returning columns', async () => {
const results = await userMapperReturningDefault
.insert()
.returnOne(USERS[0]);
expect(results).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(1);
expect(readUsers[0].handle).toEqual(USERS[0].handle);
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
results.id;
// @ts-expect-error - can't access columns when returning nothing
results[0].id;
});
});
it('inserts multiple returning configured return columns', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
expect(insertReturns.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(insertReturns[i].id).toBeGreaterThan(0);
expect(Object.keys(insertReturns[i]).length).toEqual(1);
}
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
const post0 = Object.assign({}, POSTS[0], { userId: insertReturns[0].id });
const post1 = Object.assign({}, POSTS[1], { userId: insertReturns[1].id });
const post2 = Object.assign({}, POSTS[2], { userId: insertReturns[2].id });
const updateReturns = await postTableMapperReturningIDAndTitleAsT
.insert()
.returnAll([post0, post1, post2]);
expect(updateReturns.length).toEqual(3);
for (let i = 0; i < updateReturns.length; i++) {
expect(updateReturns[i].id).toBeGreaterThan(0);
expect(updateReturns[i].t).toEqual(POSTS[i].title);
expect(Object.keys(updateReturns[i]).length).toEqual(2);
}
ignore('check return types', () => {
// @ts-expect-error - check return types
updateReturns[0].title;
// @ts-expect-error - check return types
updateReturns[0].userId;
});
});
it('inserts multiple returning no columns by default', async () => {
const insertReturns = await userMapperReturningDefault
.insert()
.returnAll(USERS);
expect(insertReturns).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
});
it('inserts multiple explicitly returning no columns', async () => {
const insertReturns = await userMapperReturningNothing
.insert()
.returnAll(USERS);
expect(insertReturns).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
insertReturns[0].id;
});
});
it('inserts multiple returning differently for inserts and updates', async () => {
const mapper = createUserMapperReturningDifferently(db);
const insertReturns = await mapper.insert().returnAll(USERS);
expect(insertReturns.length).toEqual(3);
expect(insertReturns[0]).toEqual({
id: insertReturns[0].id,
handle: USERS[0].handle,
});
// Ensure that returned objects can be accessed as expected.
((_: number) => {})(insertReturns[0].id);
((_: string) => {})(insertReturns[0].handle);
const newHandle = 'newHandle';
const updateReturns = await mapper
.update(1)
.returnAll({ handle: newHandle });
expect(updateReturns.length).toEqual(1);
expect(updateReturns[0]).toEqual({
name: USERS[0].name,
});
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(updateReturns[0].name);
ignore('type errors', () => {
// @ts-expect-error - check return types
insertReturns[0].name;
// @ts-expect-error - check return types
updateReturns[0].id;
});
});
it('inserts multiple configured to return all columns', async () => {
const insertReturns = await userMapperReturningAll
.insert()
.returnAll(USERS);
for (let i = 0; i < USERS.length; i++) {
expect(insertReturns[i].id).toBeGreaterThan(0);
}
expect(insertReturns).toEqual(
USERS.map((user, i) =>
Object.assign({}, user, { id: insertReturns[i].id })
)
);
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(insertReturns[0].name);
});
ignore('detects inserting an array of objects type errors', async () => {
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnAll([{}]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run([{}]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnAll([{ email: 'xyz@pdq.xyz' }]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run([{ email: 'xyz@pdq.xyz' }]);
// @ts-expect-error - only configured columns are returned
(await userMapperReturningID.insert().returnAll([USERS[0]]))[0].handle;
// @ts-expect-error - only configured columns are returned
(await userMapperReturningID.insert().run([USERS[0]]))[0].handle;
});
});
|
src/tests/insert-array.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " userMapperReturningAll.insert().returnOne({});\n // @ts-expect-error - inserted object must have all required columns\n userMapperReturningAll.insert().run({});\n // @ts-expect-error - inserted object must have all required columns\n userMapperReturningAll.insert().returnOne({ email: 'xyz@pdq.xyz' });\n // @ts-expect-error - inserted object must have all required columns\n userMapperReturningAll.insert().run({ email: 'xyz@pdq.xyz' });\n // @ts-expect-error - only requested columns are returned\n (await userMapperReturningID.insert().returnOne(USERS[0])).name;\n // @ts-expect-error - only requested columns are returned",
"score": 0.91900634765625
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": "});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('inserting a single object without transformation', () => {\n it('inserts one returning no columns by default', async () => {\n const success = await userMapperReturningDefault.insert().run(USERS[0]);\n expect(success).toBe(true);\n const readUser0 = await userMapperReturningAll\n .select('email', '=', USERS[0].email!)\n .returnOne();",
"score": 0.9146209359169006
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " const insertReturn = await userMapperReturningAll\n .insert()\n .returnOne(USERS[0]);\n expect(insertReturn.id).toBeGreaterThan(0);\n expect(insertReturn.email).toEqual(USERS[0].email);\n const expectedUser = Object.assign({}, USERS[0], { id: insertReturn.id });\n expect(insertReturn).toEqual(expectedUser);\n });\n ignore('detects type errors inserting a single object', async () => {\n // @ts-expect-error - inserted object must have all required columns",
"score": 0.9082685112953186
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " expect(readUser0?.email).toEqual(USERS[0].email);\n });\n it('inserts one explicitly returning no columns', async () => {\n const insertReturn = await userMapperReturningNothing\n .insert()\n .returnOne(USERS[0]);\n expect(insertReturn).toBe(undefined);\n const readUser0 = await userMapperReturningAll\n .select('email', '=', USERS[0].email!)\n .returnOne();",
"score": 0.9031549692153931
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " await userMapperReturningID.insert().run(USERS);\n const updates = await userMapperReturningNothing\n .update({ name: 'Sue' })\n .returnAll({ email: 'new.email@xyz.pdq' });\n expect(updates).toBeUndefined();\n const readUsers = await userMapperReturningID\n .select({\n email: 'new.email@xyz.pdq',\n })\n .returnAll();",
"score": 0.9027165174484253
}
] |
typescript
|
const success = await userMapperReturningDefault.insert().run(USERS);
|
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Posts } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningAll,
createUserMapperReturningNothing,
createUserMapperReturningDifferently,
} from './utils/test-mappers';
import { USERS, POSTS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
let postTableMapperReturningIDAndTitleAsT: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['id', 'title as t']
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningAll = createUserMapperReturningAll(db);
postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {
insertReturnColumns: ['id', 'title as t'],
}).withTransforms({
countTransform: (count) => Number(count),
});
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting an array of objects without transformation', () => {
it('inserts readonly objects', async () => {
const obj = {
name: 'John Doe' as const,
handle: 'johndoe' as const,
email: 'abc@def.ghi' as const,
} as const;
await userMapperReturningAll.insert().run(obj);
await userMapperReturningAll.insert().returnAll([obj]);
await userMapperReturningAll.insert().returnOne(obj);
});
it('inserts multiple via run() without returning columns', async () => {
const success = await userMapperReturningDefault.insert().run(USERS);
expect(success).toBe(true);
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
result.id;
// @ts-expect-error - can't access columns when returning nothing
result[0].id;
});
});
it('inserts multiple via returnAll() without returning columns', async () => {
const results = await userMapperReturningDefault.insert().returnAll(USERS);
expect(results).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
results.id;
// @ts-expect-error - can't access columns when returning nothing
results[0].id;
});
});
it('inserts multiple via returnOne() without returning columns', async () => {
const results = await userMapperReturningDefault
.insert()
.returnOne(USERS[0]);
expect(results).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(1);
expect(readUsers[0].handle).toEqual(USERS[0].handle);
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
results.id;
// @ts-expect-error - can't access columns when returning nothing
results[0].id;
});
});
it('inserts multiple returning configured return columns', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
expect(insertReturns.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(insertReturns[i].id).toBeGreaterThan(0);
expect(Object.keys(insertReturns[i]).length).toEqual(1);
}
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
const post0 = Object.assign({}
|
, POSTS[0], { userId: insertReturns[0].id });
|
const post1 = Object.assign({}, POSTS[1], { userId: insertReturns[1].id });
const post2 = Object.assign({}, POSTS[2], { userId: insertReturns[2].id });
const updateReturns = await postTableMapperReturningIDAndTitleAsT
.insert()
.returnAll([post0, post1, post2]);
expect(updateReturns.length).toEqual(3);
for (let i = 0; i < updateReturns.length; i++) {
expect(updateReturns[i].id).toBeGreaterThan(0);
expect(updateReturns[i].t).toEqual(POSTS[i].title);
expect(Object.keys(updateReturns[i]).length).toEqual(2);
}
ignore('check return types', () => {
// @ts-expect-error - check return types
updateReturns[0].title;
// @ts-expect-error - check return types
updateReturns[0].userId;
});
});
it('inserts multiple returning no columns by default', async () => {
const insertReturns = await userMapperReturningDefault
.insert()
.returnAll(USERS);
expect(insertReturns).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
});
it('inserts multiple explicitly returning no columns', async () => {
const insertReturns = await userMapperReturningNothing
.insert()
.returnAll(USERS);
expect(insertReturns).toBeUndefined();
const readUsers = await userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
for (let i = 0; i < USERS.length; i++) {
expect(readUsers[i].handle).toEqual(USERS[i].handle);
}
ignore("can't access columns when returning nothing", () => {
// @ts-expect-error - can't access columns when returning nothing
insertReturns[0].id;
});
});
it('inserts multiple returning differently for inserts and updates', async () => {
const mapper = createUserMapperReturningDifferently(db);
const insertReturns = await mapper.insert().returnAll(USERS);
expect(insertReturns.length).toEqual(3);
expect(insertReturns[0]).toEqual({
id: insertReturns[0].id,
handle: USERS[0].handle,
});
// Ensure that returned objects can be accessed as expected.
((_: number) => {})(insertReturns[0].id);
((_: string) => {})(insertReturns[0].handle);
const newHandle = 'newHandle';
const updateReturns = await mapper
.update(1)
.returnAll({ handle: newHandle });
expect(updateReturns.length).toEqual(1);
expect(updateReturns[0]).toEqual({
name: USERS[0].name,
});
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(updateReturns[0].name);
ignore('type errors', () => {
// @ts-expect-error - check return types
insertReturns[0].name;
// @ts-expect-error - check return types
updateReturns[0].id;
});
});
it('inserts multiple configured to return all columns', async () => {
const insertReturns = await userMapperReturningAll
.insert()
.returnAll(USERS);
for (let i = 0; i < USERS.length; i++) {
expect(insertReturns[i].id).toBeGreaterThan(0);
}
expect(insertReturns).toEqual(
USERS.map((user, i) =>
Object.assign({}, user, { id: insertReturns[i].id })
)
);
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(insertReturns[0].name);
});
ignore('detects inserting an array of objects type errors', async () => {
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnAll([{}]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run([{}]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnAll([{ email: 'xyz@pdq.xyz' }]);
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run([{ email: 'xyz@pdq.xyz' }]);
// @ts-expect-error - only configured columns are returned
(await userMapperReturningID.insert().returnAll([USERS[0]]))[0].handle;
// @ts-expect-error - only configured columns are returned
(await userMapperReturningID.insert().run([USERS[0]]))[0].handle;
});
});
|
src/tests/insert-array.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " expect(insertReturn1.id).toBeGreaterThan(0);\n expect(Object.keys(insertReturn1).length).toEqual(1);\n const readUser0 = await userMapperReturningAll\n .select('id', '=', insertReturn1.id)\n .returnOne();\n expect(readUser0?.email).toEqual(USERS[0].email);\n const post0 = Object.assign({}, POSTS[0], { userId: insertReturn1.id });\n const insertReturn2 = await postTableMapperReturningIDAndTitleAsT\n .insert()\n .returnOne(post0);",
"score": 0.9489132165908813
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " const expectedUsers = USERS.map((user, i) => ({\n id: insertReturns[i].id,\n h: user.handle,\n }));\n expect(updateReturns).toEqual(expectedUsers);\n const readUsers = await userMapperReturningID.select().returnAll();\n expect(readUsers.length).toEqual(3);\n for (const user of readUsers) {\n expect(user.email).toEqual(updateValues.email);\n }",
"score": 0.9316462278366089
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " const readUsers = await insertTransformMapper\n .select('id', '>', insertReturn.id)\n .returnAll();\n expect(readUsers.length).toEqual(2);\n expect(readUsers[0].name).toEqual(\n `${insertedUser2.firstName} ${insertedUser2.lastName}`\n );\n expect(readUsers[1].name).toEqual(\n `${insertedUser3.firstName} ${insertedUser3.lastName}`\n );",
"score": 0.9266703724861145
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " insertReturn2.userId;\n });\n });\n it('inserts multiple returning differently for inserts and updates', async () => {\n const mapper = createUserMapperReturningDifferently(db);\n const insertReturn = await mapper.insert().returnOne(USERS[0]);\n expect(insertReturn).toEqual({\n id: 1,\n handle: USERS[0].handle,\n });",
"score": 0.9243946075439453
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " await userMapperReturningID.insert().run(USERS[1]);\n await userMapperReturningID.insert().run(USERS[2]);\n const updateCount1 = await userMapperReturningAll\n .update({ id: insertReturn0.id })\n .returnCount(updateValues);\n expect(updateCount1).toEqual(1);\n const readUser1 = await userMapperReturningID\n .select('id', '=', insertReturn0.id)\n .returnOne();\n expect(readUser1?.email).toEqual(updateValues.email);",
"score": 0.9219827651977539
}
] |
typescript
|
, POSTS[0], { userId: insertReturns[0].id });
|
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Posts } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningAll,
createUserMapperReturningNothing,
createUserMapperReturningDifferently,
} from './utils/test-mappers';
import { USERS, POSTS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
let postTableMapper: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['*']
>;
let postTableMapperReturningIDAndTitleAsT: TableMapper<
Database,
'posts',
[],
['*'],
Selectable<Posts>,
Insertable<Posts>,
Updateable<Posts>,
number,
['id', 'title as t']
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningAll = createUserMapperReturningAll(db);
postTableMapper = new TableMapper(db, 'posts', {
insertReturnColumns: ['*'],
}).withTransforms({
countTransform: (count) => Number(count),
});
postTableMapperReturningIDAndTitleAsT = new TableMapper(db, 'posts', {
insertReturnColumns: ['id', 'title as t'],
}).withTransforms({
countTransform: (count) => Number(count),
});
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting a single object without transformation', () => {
it('inserts one returning no columns by default', async () => {
const success = await
|
userMapperReturningDefault.insert().run(USERS[0]);
|
expect(success).toBe(true);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
});
it('inserts one explicitly returning no columns', async () => {
const insertReturn = await userMapperReturningNothing
.insert()
.returnOne(USERS[0]);
expect(insertReturn).toBe(undefined);
const readUser0 = await userMapperReturningAll
.select('email', '=', USERS[0].email!)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
ignore('type errors', () => {
// @ts-expect-error - check return type
insertReturn.id;
});
});
it('inserts one returning configured return columns', async () => {
const insertReturn1 = await userMapperReturningID
.insert()
.returnOne(USERS[0]);
expect(insertReturn1.id).toBeGreaterThan(0);
expect(Object.keys(insertReturn1).length).toEqual(1);
const readUser0 = await userMapperReturningAll
.select('id', '=', insertReturn1.id)
.returnOne();
expect(readUser0?.email).toEqual(USERS[0].email);
const post0 = Object.assign({}, POSTS[0], { userId: insertReturn1.id });
const insertReturn2 = await postTableMapperReturningIDAndTitleAsT
.insert()
.returnOne(post0);
expect(insertReturn2.id).toBeGreaterThan(0);
expect(insertReturn2.t).toEqual(POSTS[0].title);
expect(Object.keys(insertReturn2).length).toEqual(2);
const readPost0 = await postTableMapper
.select(({ and, cmpr }) =>
and([
cmpr('id', '=', insertReturn2.id),
cmpr('title', '=', insertReturn2.t),
])
)
.returnOne();
expect(readPost0?.likeCount).toEqual(post0.likeCount);
ignore('check return types', () => {
// @ts-expect-error - check return types
insertReturn1.title;
// @ts-expect-error - check return types
insertReturn1.userId;
// @ts-expect-error - check return types
insertReturn2.title;
// @ts-expect-error - check return types
insertReturn2.userId;
});
});
it('inserts multiple returning differently for inserts and updates', async () => {
const mapper = createUserMapperReturningDifferently(db);
const insertReturn = await mapper.insert().returnOne(USERS[0]);
expect(insertReturn).toEqual({
id: 1,
handle: USERS[0].handle,
});
// Ensure that returned objects can be accessed as expected.
((_: number) => {})(insertReturn.id);
((_: string) => {})(insertReturn.handle);
const newHandle = 'newHandle';
const updateReturn = await mapper
.update(1)
.returnOne({ handle: newHandle });
expect(updateReturn).toEqual({
name: USERS[0].name,
});
// Ensure that returned objects can be accessed as expected.
((_: string) => {})(updateReturn!.name);
ignore('type errors', () => {
// @ts-expect-error - check return types
insertReturn.name;
// @ts-expect-error - check return types
updateReturn!.id;
});
});
it('inserts one configured to return all columns', async () => {
const insertReturn = await userMapperReturningAll
.insert()
.returnOne(USERS[0]);
expect(insertReturn.id).toBeGreaterThan(0);
expect(insertReturn.email).toEqual(USERS[0].email);
const expectedUser = Object.assign({}, USERS[0], { id: insertReturn.id });
expect(insertReturn).toEqual(expectedUser);
});
ignore('detects type errors inserting a single object', async () => {
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({});
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().returnOne({ email: 'xyz@pdq.xyz' });
// @ts-expect-error - inserted object must have all required columns
userMapperReturningAll.insert().run({ email: 'xyz@pdq.xyz' });
// @ts-expect-error - only requested columns are returned
(await userMapperReturningID.insert().returnOne(USERS[0])).name;
// @ts-expect-error - only requested columns are returned
(await userMapperReturningDefault.insert().run(USERS[0])).name;
});
});
|
src/tests/insert-single.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": "});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('inserting with transformation', () => {\n it('transforms users for insertion without transforming return', async () => {\n const insertTransformMapper = createInsertTransformMapper(db);\n const insertReturn = await insertTransformMapper\n .insert()\n .returnOne(insertedUser1);\n const readUser1 = await insertTransformMapper",
"score": 0.9280346035957336
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " expect(users.length).toEqual(1);\n expect(users[0].handle).toEqual(USERS[1].handle);\n });\n it('deletes rows returning the deletion count inferred as a number', async () => {\n const testMapper = new TableMapper(db, 'users').withTransforms({\n countTransform: (count) => Number(count),\n });\n await testMapper.insert().run(USERS);\n const count = await testMapper\n .delete({ name: USERS[0].name })",
"score": 0.9061998128890991
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " expect(readUsers.length).toEqual(3);\n for (let i = 0; i < USERS.length; i++) {\n expect(readUsers[i].handle).toEqual(USERS[i].handle);\n }\n });\n it('inserts multiple explicitly returning no columns', async () => {\n const insertReturns = await userMapperReturningNothing\n .insert()\n .returnAll(USERS);\n expect(insertReturns).toBeUndefined();",
"score": 0.9056705832481384
},
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " const insertTransformMapper = createInsertTransformMapper(db);\n // @ts-expect-error - requires InsertedObject as input\n await insertTransformMapper.insert().returnOne(USERS[0]);\n // @ts-expect-error - requires InsertedObject as input\n await insertTransformMapper.insert().run(USERS[0]);\n // @ts-expect-error - requires InsertedObject as input\n await insertTransformMapper.insert().returnOne(selectedUser1);\n // @ts-expect-error - requires InsertedObject as input\n await insertTransformMapper.insert().run(selectedUser1);\n });",
"score": 0.9005928039550781
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " name: 'John Doe' as const,\n handle: 'johndoe' as const,\n email: 'abc@def.ghi' as const,\n } as const;\n await userMapperReturningAll.insert().run(obj);\n await userMapperReturningAll.insert().returnAll([obj]);\n await userMapperReturningAll.insert().returnOne(obj);\n });\n it('inserts multiple via run() without returning columns', async () => {\n const success = await userMapperReturningDefault.insert().run(USERS);",
"score": 0.900528609752655
}
] |
typescript
|
userMapperReturningDefault.insert().run(USERS[0]);
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
|
source: SelectedUser | Updateable<Database['users']>
) => {
|
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
|
src/tests/insert-transforms.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n insertReturnTransform: (source: User, returns) => ({\n id: returns.id,\n firstName: source.firstName,\n lastName: source.lastName,\n }),\n updateTransform: (source: User) => ({",
"score": 0.90108323097229
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n updateReturnTransform: (source: User, returns) => ({\n id: returns.id,\n firstName: source.firstName,\n lastName: source.lastName,\n }),\n countTransform: (count) => Number(count),",
"score": 0.8949901461601257
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " updateTransform: (source: UpdatingUser, columns) => {\n expect(columns).toEqual(['*']);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n updateReturnTransform: (source: UpdatingUser, returns) =>\n new ReturnedUser(",
"score": 0.8819969892501831
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " }),\n insertReturnTransform: (_source, returns) => {\n const names = returns.name.split(' ');\n return new User(\n returns.id,\n names[0],\n names[1],\n returns.handle,\n returns.email\n );",
"score": 0.8752238750457764
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " updateReturnColumns: ['*'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,",
"score": 0.8735028505325317
}
] |
typescript
|
source: SelectedUser | Updateable<Database['users']>
) => {
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform:
|
(source, returns) => {
|
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
|
src/tests/insert-transforms.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " name: 'Suzanne Smith',\n }),\n ]);\n });\n it('transforms update return into object without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateReturnTransform: (source, returns) =>",
"score": 0.9228522777557373
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " it('transforms update return into primitive without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n insertReturnTransform: (_source, returns) => returns.id,\n updateReturnTransform: (_source, returns) => returns.id,\n });\n const insertReturn = await updateReturnTransformMapper\n .insert()",
"score": 0.9128850102424622
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " it('parameterizes an update query with transformation', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({",
"score": 0.9078514575958252
},
{
"filename": "src/tests/insert-single.test.ts",
"retrieved_chunk": " insertReturn2.userId;\n });\n });\n it('inserts multiple returning differently for inserts and updates', async () => {\n const mapper = createUserMapperReturningDifferently(db);\n const insertReturn = await mapper.insert().returnOne(USERS[0]);\n expect(insertReturn).toEqual({\n id: 1,\n handle: USERS[0].handle,\n });",
"score": 0.9075576663017273
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " user1\n );\n const expectedReturn3 = {\n id: insertReturns[2].id,\n firstName: user1.firstName,\n lastName: user1.lastName,\n };\n expect(success1).toBe(true);\n // verify updates\n const readUsers = await transformMapper.select().returnAll();",
"score": 0.9074455499649048
}
] |
typescript
|
(source, returns) => {
|
import { effectReset, forgroundRGBColor } from "#/colors";
import { FormatConfig } from "./formatter.type";
import { RGB, isInRGBRange, isRGBValues, removeEscapeSequence } from "#/utils/color";
import { defaultFormatConfig, defaultRainbowStartColor } from "./formatter.const";
import { charIndexes, concatCharIndexes, linearGradientIndex, nextRGBValue } from "./formatter.util";
export const linearGradient = (message: string, start: RGB, end: RGB, ignoreSpaces = true): string => {
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values (start). Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
if (!isRGBValues(end)) {
throw new Error(`Invalid RGB values (end). Values must be in [0, 255]: red=\`${end.red}\`, green=\`${end.green}\`, blue=\`${end.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
if (tempMessage.length <= 1) {
newMessage.push(`${forgroundRGBColor(start)}${tempMessage}`);
} else {
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
continue;
}
const color = linearGradientIndex(start, end, (i / (tempMessage.length - 1)));
newMessage.push(`${forgroundRGBColor(color)}${tempMessage[i]}`);
}
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
export const matrix = (message: string, color: RGB, force = 100): string => {
if (!isRGBValues(color)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${color.red}\`, green=\`${color.green}\`, blue=\`${color.blue}\``);
}
if (!isInRGBRange(force)) throw new Error(`Invalid force. Value must be in [0, 255]: force=\`${force}\``);
message = removeEscapeSequence(message);
let newMessage = "";
for (let i = 0; i < message.length; i++) {
if (message[i] === " ") {
newMessage += message[i];
continue;
}
const num = Math.round(Math.random() * force); // Random number between 0 and force
// For each value cross-product
const colorNuance: RGB = {
red: Math.floor(color.red * ((255 - num) / 255)),
green: Math.floor(color.green * ((255 - num) / 255)),
blue: Math.floor(color.blue * ((255 - num) / 255))
};
newMessage += `${forgroundRGBColor(colorNuance)}${message[i]}`;
}
return `${newMessage}${effectReset.all}`;
};
export const rainbow = (message
|
: string, start: RGB = defaultRainbowStartColor, step = 15, ignoreSpaces = true): string => {
|
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
let nextColor = start;
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
} else {
newMessage.push(`${forgroundRGBColor(nextColor)}${tempMessage[i]}`);
}
nextColor = nextRGBValue(nextColor, step);
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
export const format = (message: string, formatConfig: FormatConfig = defaultFormatConfig): string => {
const regex = new RegExp(Object.keys(formatConfig).join("|"), "g");
return message.replace(regex, match => formatConfig[match]);
};
|
src/formatters/formatter.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/formatters/formatter.util.ts",
"retrieved_chunk": " red: Math.floor(start.red + (end.red - start.red) * index),\n green: Math.floor(start.green + (end.green - start.green) * index),\n blue: Math.floor(start.blue + (end.blue - start.blue) * index)\n };\n};\nexport const nextRGBValue = (color: RGB, step: number): RGB => {\n if (!isRGBValues(color)) {\n throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\\`${color.red}\\`, green=\\`${color.green}\\`, blue=\\`${color.blue}\\``);\n }\n const maxStep = (255 - Math.min(color.red, color.green, color.blue)) * 6; // Max different RGB values",
"score": 0.8336871862411499
},
{
"filename": "src/formatters/formatter.const.ts",
"retrieved_chunk": "import { FormatConfig } from \"./formatter.type\";\nimport { RGB } from \"#/utils/color\";\nimport { effect, effectReset, forground } from \"#/colors\";\nexport const defaultRainbowStartColor: RGB = {\n red: 255,\n green: 0,\n blue: 0\n} as const;\nexport const defaultFormatConfig: FormatConfig = {\n \"§0\": forground.black,",
"score": 0.8295208811759949
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma \\u001B[38;2;115;141;230ma\\u001B[38;2;115;126;230ma\\u001B[0m\");\n expect(rainbow(\" aa\", { red: 115, green: 230, blue: 214 }, undefined, false))\n .toBe(\" \\u001B[38;2;115;171;230ma\\u001B[38;2;115;156;230ma\\u001B[0m\");\n });\n it(\"should return a formatted string with ignoring spaces and have different step\", () => {\n expect(rainbow(\"\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[0m\");\n expect(rainbow(\"a\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[0m\");\n expect(rainbow(\"aa\", { red: 115, green: 230, blue: 214 }, 150))",
"score": 0.8234651684761047
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma\\u001B[38;2;115;216;230ma\\u001B[0m\");\n expect(rainbow(\"aaaaa\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma\\u001B[38;2;115;216;230ma\\u001B[38;2;115;201;230ma\\u001B[38;2;115;186;230ma\\u001B[0m\");\n expect(rainbow(\"aa aa\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma \\u001B[38;2;115;216;230ma\\u001B[38;2;115;201;230ma\\u001B[0m\");\n expect(rainbow(\" aa\", { red: 115, green: 230, blue: 214 }))\n .toBe(\" \\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma\\u001B[0m\");\n });\n it(\"should return a formatted string without ignoring spaces and start at different color\", () => {\n expect(rainbow(\"\", { red: 115, green: 230, blue: 214 }, undefined, false))",
"score": 0.8197634816169739
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toBe(\" \\u001B[38;2;255;75;0ma\\u001B[38;2;255;90;0ma\\u001B[0m\");\n });\n it(\"should return a formatted string with ignoring spaces and start at different color\", () => {\n expect(rainbow(\"\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[0m\");\n expect(rainbow(\"a\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[0m\");\n expect(rainbow(\"aa\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma\\u001B[0m\");\n expect(rainbow(\"aaa\", { red: 115, green: 230, blue: 214 }))",
"score": 0.8182714581489563
}
] |
typescript
|
: string, start: RGB = defaultRainbowStartColor, step = 15, ignoreSpaces = true): string => {
|
import { charIndexes, concatCharIndexes, linearGradientIndex, nextRGBValue } from "../formatter.util";
import { RGB } from "#/utils/color";
import { describe, expect, it } from "vitest";
describe("`linearGradientIndex` function", () => {
it("should return a RGB value", () => {
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0))
.toStrictEqual<RGB>({ red: 255, green: 0, blue: 112 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.2))
.toStrictEqual<RGB>({ red: 209, green: 48, blue: 94 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.4))
.toStrictEqual<RGB>({ red: 163, green: 96, blue: 76 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.6))
.toStrictEqual<RGB>({ red: 117, green: 144, blue: 58 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.8))
.toStrictEqual<RGB>({ red: 71, green: 192, blue: 40 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 1))
.toStrictEqual<RGB>({ red: 25, green: 240, blue: 22 });
});
it("should throw an error", () => {
expect(() => linearGradientIndex({ red: -1, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: -1, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: -1 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
expect(() => linearGradientIndex({ red: 256, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 256, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 256 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: -1, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: -1, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: -1 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 256, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 256, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 256 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, -1))
.toThrow("Index must be in range [0,1]: index=`-1`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, 2))
.toThrow("Index must be in range [0,1]: index=`2`");
});
});
describe("`nextRGBValue` function", () => {
it("should return a RGB value", () => {
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 0))
.toStrictEqual<RGB>({ red: 255, green: 0, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 1530))
.toStrictEqual<RGB>({ red: 255, green: 0, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 10))
.toStrictEqual<RGB>({ red: 255, green: 10, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 50))
.toStrictEqual<RGB>({ red: 255, green: 50, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 100))
.toStrictEqual<RGB>({ red: 255, green: 100, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 500))
.toStrictEqual<RGB>({ red: 10, green: 255, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 1000))
.toStrictEqual<RGB>({ red: 0, green: 20, blue: 255 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 0))
.toStrictEqual<RGB>({ red: 47, green: 61, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 1248))
.toStrictEqual<RGB>({ red: 47, green: 61, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 1530))
.toStrictEqual<RGB>({ red: 49, green: 74, blue: 47 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 10))
.toStrictEqual<RGB>({ red: 47, green: 51, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 50))
.toStrictEqual<RGB>({ red: 74, green: 47, blue: 65 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 100))
.toStrictEqual<RGB>({ red: 69, green: 74, blue: 47 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 500))
.toStrictEqual<RGB>({ red: 47, green: 47, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 1000))
.toStrictEqual<RGB>({ red: 61, green: 47, blue: 74 });
});
it("should throw an error", () => {
expect(() => nextRGBValue({ red: -1, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: -1, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: 0, blue: -1 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
expect(() => nextRGBValue({ red: 256, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: 256, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: 0, blue: 256 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`");
});
});
describe("`charIndexes` function", () => {
it("should return an array of indexes", () => {
expect(charIndexes("", " ")).toStrictEqual([]);
expect(charIndexes("foo", " ")).toStrictEqual([]);
expect(charIndexes("foo bar", " ")).toStrictEqual([3]);
expect(charIndexes("foo bar", " ")).toStrictEqual([3]);
expect(charIndexes("foo bar", " ")).toStrictEqual([3]);
expect(charIndexes("foo bar toto titi tata tutu tete", " ")).toStrictEqual([3, 7, 12, 17, 22, 27]);
expect(charIndexes("foo bar toto titi tata tutu tete", "a")).toStrictEqual([5, 19, 21]);
});
});
describe("`concatCharIndexes` function", () => {
it("should return an array of string", () => {
|
expect(concatCharIndexes([], [], "foo")).toStrictEqual([]);
|
expect(concatCharIndexes([], [1], "foo")).toStrictEqual(["foo"]);
expect(concatCharIndexes(["bar"], [], "foo")).toStrictEqual(["bar"]);
expect(concatCharIndexes(["bar"], [0], "foo")).toStrictEqual(["foo", "bar"]);
expect(concatCharIndexes(["bar"], [1], "foo")).toStrictEqual(["bar", "foo"]);
expect(concatCharIndexes(["bar"], [0, 3], "foo")).toStrictEqual(["foo", "bar", "foo"]);
expect(concatCharIndexes(["bar"], [1, 3], "foo")).toStrictEqual(["bar", "foo", "foo"]);
expect(concatCharIndexes(["bar", "toto", "titi", "tata", "tutu", "tete"], [1, 19, 3, 8], "foo"))
.toStrictEqual(["bar", "foo", "toto", "foo", "titi", "tata", "tutu", "tete", "foo", "foo"]);
});
});
|
src/formatters/_test/formatter.util.test.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/formatters/formatter.util.ts",
"retrieved_chunk": " const spaceIndex: number[] = [];\n for (let i = 0; i < message.length; i++) {\n if (message[i] !== char) continue;\n spaceIndex.push(i);\n }\n return spaceIndex;\n};\nexport const concatCharIndexes = (message: string[], charIndexes : number[], char: string): string[] => {\n charIndexes.sort((a, b) => a - b);\n for (const index of charIndexes) {",
"score": 0.8500480055809021
},
{
"filename": "src/utils/color/_test/color.util.test.ts",
"retrieved_chunk": " expect(removeEscapeSequence(\"a\\u001B[0;1ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0;1;12ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0;1;12;123ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0;1;12;123;1234ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0;1;12;123;1234;1345ma\")).toBe(\"aa\");\n });\n});",
"score": 0.795540452003479
},
{
"filename": "src/utils/color/_test/color.util.test.ts",
"retrieved_chunk": " expect(() => hexToRgb(\"#0000AG\")).toThrow(\"`#0000AG` isn't a hexadecimal color code\");\n expect(() => hexToRgb(\"#0-_\")).toThrow(\"`#0-_` isn't a hexadecimal color code\");\n });\n});\ndescribe(\"`removeEscapeSequence` function\", () => {\n it(\"should return a string without ANSI escape sequences\", () => {\n expect(removeEscapeSequence(\"\\u001B[0ma\")).toBe(\"a\");\n expect(removeEscapeSequence(\"a\\u001B[0ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"\\u001B[0ma\\u001B[0ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0ma\\u001B[0ma\")).toBe(\"aaa\");",
"score": 0.7912169098854065
},
{
"filename": "src/colors/_test/color.test.ts",
"retrieved_chunk": " it(\"should throw an error\", () => {\n expect(() => forground256Color(-1)).toThrow(\"Invalid colorId. Value must be in [0, 255]: colorId=`-1`\");\n expect(() => forground256Color(256)).toThrow(\"Invalid colorId. Value must be in [0, 255]: colorId=`256`\");\n });\n});\ndescribe(\"`backround256Color` function\", () => {\n it(\"should return an escape sequence\", () => {\n expect(background256Color(0)).toBe(\"\\x1b[48;5;0m\");\n expect(background256Color(128)).toBe(\"\\x1b[48;5;128m\");\n expect(background256Color(255)).toBe(\"\\x1b[48;5;255m\");",
"score": 0.7878056764602661
},
{
"filename": "src/formatters/formatter.util.ts",
"retrieved_chunk": " remainingSteps -= valueToRemove;\n }\n }\n return {\n red: colorsArray[0].color,\n green: colorsArray[1].color,\n blue: colorsArray[2].color\n };\n};\nexport const charIndexes = (message: string, char: string): number[] => {",
"score": 0.7855558395385742
}
] |
typescript
|
expect(concatCharIndexes([], [], "foo")).toStrictEqual([]);
|
/**
* Tests TableMapper.selectMany(), TableMapper.selectOne(), and query filters.
*/
import { Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningID(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('general selection', () => {
it('compiles an unparameterized select query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.select({ name: USERS[0].name }).compile();
const users = await compilation.returnAll({});
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
const user = await compilation.returnOne({});
expect(user?.handle).toEqual(USERS[0].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
ignore('compilation type errors', () => {
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
});
});
it('parameterizes and compiles a select query', async () => {
await userMapper.insert().run(USERS);
const parameterization = userMapper.parameterize<{ name: string }>(
({ mapper, param }) => mapper.select({ name: param('name') })
);
// test returnAll() returning multiple
const users = await parameterization.returnAll({ name: USERS[0].name });
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
// test returnAll() returning none
const users2 = await parameterization.returnAll({ name: 'not there' });
expect(users2.length).toEqual(0);
// test returnOne() returning one
const user = await parameterization.returnOne({ name: USERS[1].name });
expect(user?.handle).toEqual(USERS[1].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
// test returnOne() returning none
const user2 = await parameterization.returnOne({ name: 'not there' });
expect(user2).toBeNull();
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ notThere: 'foo' });
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ name: 123 });
});
});
it('modifies the underlying query builder', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[2].handle);
expect(users[1].handle).toEqual(USERS[0].handle);
const user = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnOne();
expect(user?.handle).toEqual(USERS[2].handle);
});
it('does not modify the underlying selected columns', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnAll();
expect(users).toEqual([
{ ...USERS[2], id: 3 },
{ ...USERS[1], id: 2 },
{ ...USERS[0], id: 1 },
]);
// Ensure that columns can be addressed by name.
((_: number) => {})(users[0].id);
((_: string) => {})(users[0].handle);
((_: string) => {})(users[0].name);
((_: string) => {})(users[0].email!);
const user = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnOne();
expect(user).toEqual({ ...USERS[2], id: 3 });
// Ensure that columns can be addressed by name.
((_: number) => {})(user!.id);
((_: string) => {})(user!.handle);
((_: string) => {})(user!.name);
((_: string) => {})(user!.email!);
ignore('detects modify() type errors', async () => {
// @ts-expect-error - cannot access invalid columns
users[0].notThere;
// @ts-expect-error - cannot access invalid columns
user!.notThere;
});
});
it('selects via a multi-column key tuple (definition order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id', 'name'],
});
await mapper.insert().run(USERS);
const users = await mapper.select([3, 'Sue']).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
it('selects via a multi-column key tuple (different order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['name', 'id'],
});
await mapper.insert().run(USERS);
const users = await mapper.select(['Sue', 3]).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
ignore('detects select(filter) type errors', async () => {
// @ts-expect-error - doesn't allow only two arguments
userMapper.select('name', '=');
// @ts-expect-error - object filter fields must be valid
userMapper.select({ notThere: 'xyz' });
userMapper.select(({
|
or, cmpr }) =>
// @ts-expect-error - where expression columns must be valid
or([cmpr('notThere', '=', 'Sue')])
);
|
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('notThere', '=', 'foo');
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('users.notThere', '=', 'foo');
// @ts-expect-error - ID filter must have correct type
userMapper.select('str');
// @ts-expect-error - ID filter must have correct type
userMapper.select(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select([1]);
});
});
|
src/tests/select-general.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " ]);\n ignore('inaccessible types are not allowed', async () => {\n // @ts-expect-error - aliases are not allowed in filter expressions\n mapper.select({ h: USERS[0].handle });\n // @ts-expect-error - unselected columns are not allowed\n (await mapper.select().returnAll())[0].name;\n });\n });\n ignore(\n 'detects selecting returnAll() simple filter type errors',",
"score": 0.9198237061500549
},
{
"filename": "src/tests/select-one.test.ts",
"retrieved_chunk": " // @ts-expect-error - unselected columns are not allowed\n (await mapper.select().returnAll())[0].name;\n });\n });\n ignore('detects selecting returnOne() type errors', async () => {\n // @ts-expect-error - only table columns are accessible unfiltered\n (await userMapper.select({}).returnOne()).notThere;\n // @ts-expect-error - only table columns are accessible w/ object filter\n (await userMapper.select({ name: 'Sue' }).returnOne()).notThere;\n // @ts-expect-error - only table columns are accessible w/ op filter",
"score": 0.9129487872123718
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " ignore('detects deletion type errors', async () => {\n // @ts-expect-error - table must have all filter fields\n userMapper.delete({ notThere: 'xyz' });\n // @ts-expect-error - table must have all filter fields\n userMapper.delete('notThere', '=', 'foo');\n userMapper.delete(({ or, cmpr }) =>\n // @ts-expect-error - only table columns are accessible via anyOf()\n or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])\n );\n userMapper.delete(({ or, cmpr }) =>",
"score": 0.9089862108230591
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " async () => {\n // @ts-expect-error - only table columns are accessible unfiltered\n (await userMapper.select().returnAll())[0].notThere;\n // @ts-expect-error - only table columns are accessible unfiltered\n (await userMapper.select({}).returnAll())[0].notThere;\n // @ts-expect-error - only table columns are accessible w/ object filter\n // prettier-ignore\n (await userMapper.select({ name: \"Sue\" }).returnAll())[0].notThere;\n // @ts-expect-error - only table columns are accessible w/ op filter\n // prettier-ignore",
"score": 0.8999271392822266
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " expect(count3).toEqual(1);\n const users2 = await userMapper.select().returnAll();\n expect(users2.length).toEqual(0);\n ignore('parameterization type errors', () => {\n // @ts-expect-error - errors on invalid parameter names\n parameterization.run({ notThere: 'foo' });\n userMapper.parameterize<{ name: string }>(\n // @ts-expect-error - errors on invalid parameter name\n ({ mapper, param }) => mapper.select({ name: param('notThere') })\n );",
"score": 0.8991798162460327
}
] |
typescript
|
or, cmpr }) =>
// @ts-expect-error - where expression columns must be valid
or([cmpr('notThere', '=', 'Sue')])
);
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source
|
: InsertedUser, columns) => {
|
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
|
src/tests/insert-transforms.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " expect(updateReturn2).toEqual(1);\n // Ensure the returned value is accessible as a number\n ((_: number) => {})(updateReturn2!);\n });\n it(\"transforms update and update return, columns is ['*']\", async () => {\n expect.assertions(2);\n const updateAndReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({",
"score": 0.9317812919616699
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " expect(success).toBe(true);\n });\n it('provides insertTransform with column subset', async () => {\n expect.assertions(1);\n const mapper = userMapperReturningID.withTransforms({\n insertTransform: (source, columns) => {\n expect(columns).toEqual(['name', 'handle']);\n return source;\n },\n });",
"score": 0.9172027707099915
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " ((_: string) => {})(updateReturns[0].name);\n ignore('type errors', () => {\n // @ts-expect-error - check return types\n insertReturns[0].name;\n // @ts-expect-error - check return types\n updateReturns[0].id;\n });\n });\n it('inserts multiple configured to return all columns', async () => {\n const insertReturns = await userMapperReturningAll",
"score": 0.9118773937225342
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " // Ensure that returned objects can be accessed as expected.\n ((_: string) => {})(insertReturns[0].name);\n });\n ignore('detects inserting an array of objects type errors', async () => {\n // @ts-expect-error - inserted object must have all required columns\n userMapperReturningAll.insert().returnAll([{}]);\n // @ts-expect-error - inserted object must have all required columns\n userMapperReturningAll.insert().run([{}]);\n // @ts-expect-error - inserted object must have all required columns\n userMapperReturningAll.insert().returnAll([{ email: 'xyz@pdq.xyz' }]);",
"score": 0.9110237956047058
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(insertReturn!.name);\n // test run()\n const success1 = await compilation.run(USERS[1]);\n expect(success1).toBe(true);\n // test that non-specified columns are not inserted\n const success2 = await compilation.run({ ...USERS[2], id: 100 });\n expect(success2).toBe(true);\n const readUsers = await userMapperReturningAll.select().returnAll();\n expect(readUsers.length).toEqual(3);",
"score": 0.9086593389511108
}
] |
typescript
|
: InsertedUser, columns) => {
|
import { effectReset, forgroundRGBColor } from "#/colors";
import { FormatConfig } from "./formatter.type";
import { RGB, isInRGBRange, isRGBValues, removeEscapeSequence } from "#/utils/color";
import { defaultFormatConfig, defaultRainbowStartColor } from "./formatter.const";
import { charIndexes, concatCharIndexes, linearGradientIndex, nextRGBValue } from "./formatter.util";
export const linearGradient = (message: string, start: RGB, end: RGB, ignoreSpaces = true): string => {
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values (start). Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
if (!isRGBValues(end)) {
throw new Error(`Invalid RGB values (end). Values must be in [0, 255]: red=\`${end.red}\`, green=\`${end.green}\`, blue=\`${end.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
if (tempMessage.length <= 1) {
newMessage.push(`${forgroundRGBColor(start)}${tempMessage}`);
} else {
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
continue;
}
const color = linearGradientIndex(start, end, (i / (tempMessage.length - 1)));
newMessage.push(`${forgroundRGBColor(color)}${tempMessage[i]}`);
}
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
export const matrix = (message: string, color: RGB, force = 100): string => {
if (!isRGBValues(color)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${color.red}\`, green=\`${color.green}\`, blue=\`${color.blue}\``);
}
if (!isInRGBRange(force)) throw new Error(`Invalid force. Value must be in [0, 255]: force=\`${force}\``);
message = removeEscapeSequence(message);
let newMessage = "";
for (let i = 0; i < message.length; i++) {
if (message[i] === " ") {
newMessage += message[i];
continue;
}
const num = Math.round(Math.random() * force); // Random number between 0 and force
// For each value cross-product
const colorNuance: RGB = {
red: Math.floor(color.red * ((255 - num) / 255)),
green: Math.floor(color.green * ((255 - num) / 255)),
blue: Math.floor(color.blue * ((255 - num) / 255))
};
newMessage += `${forgroundRGBColor(colorNuance)}${message[i]}`;
}
return `${newMessage}${effectReset.all}`;
};
export const rainbow = (message: string, start: RGB = defaultRainbowStartColor, step = 15, ignoreSpaces = true): string => {
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
let nextColor = start;
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
} else {
newMessage.push(`${forgroundRGBColor(nextColor)}${tempMessage[i]}`);
}
nextColor = nextRGBValue(nextColor, step);
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
export const
|
format = (message: string, formatConfig: FormatConfig = defaultFormatConfig): string => {
|
const regex = new RegExp(Object.keys(formatConfig).join("|"), "g");
return message.replace(regex, match => formatConfig[match]);
};
|
src/formatters/formatter.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/formatters/formatter.util.ts",
"retrieved_chunk": " const spaceIndex: number[] = [];\n for (let i = 0; i < message.length; i++) {\n if (message[i] !== char) continue;\n spaceIndex.push(i);\n }\n return spaceIndex;\n};\nexport const concatCharIndexes = (message: string[], charIndexes : number[], char: string): string[] => {\n charIndexes.sort((a, b) => a - b);\n for (const index of charIndexes) {",
"score": 0.8378685116767883
},
{
"filename": "src/formatters/formatter.util.ts",
"retrieved_chunk": " message = message.slice(0, index).concat([char], message.slice(index));\n }\n return message;\n};",
"score": 0.8088116645812988
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " };\n expect(format(\"\", formatConfig)).toBe(\"\");\n expect(format(\"a\", formatConfig)).toBe(\"a\");\n expect(format(\"aa\", formatConfig)).toBe(\"aa\");\n expect(format(\"§2aa\", formatConfig)).toBe(\"§\\u001B[31maa\");\n expect(format(\"§a2a\", formatConfig)).toBe(\"§a2a\");\n expect(format(\"§2§baa\", formatConfig)).toBe(\"§\\u001B[31m§baa\");\n });\n it(\"should return a formatted string with custom & default values passed in parameters replace by their replacement\", () => {\n const formatConfig: FormatConfig = {",
"score": 0.8066070079803467
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " ...defaultFormatConfig,\n \"§1\": forground.black,\n \"§2\": `§${forground.red}`,\n \"§3\": `§${forground.green}`,\n \"§4\": `§${forground.yellow}`\n };\n expect(format(\"\", formatConfig)).toBe(\"\");\n expect(format(\"a\", formatConfig)).toBe(\"a\");\n expect(format(\"aa\", formatConfig)).toBe(\"aa\");\n expect(format(\"§2aa\", formatConfig)).toBe(\"§\\u001B[31maa\");",
"score": 0.8047606348991394
},
{
"filename": "src/colors/colors.const.ts",
"retrieved_chunk": " strikethrough: `${openANSI}9${closeANSI}`\n} as const;\nexport const effectReset = {\n all: `${openANSI}0${closeANSI}`,\n bold: `${openANSI}22${closeANSI}`,\n thin: `${openANSI}22${closeANSI}`,\n italic: `${openANSI}23${closeANSI}`,\n underline: `${openANSI}24${closeANSI}`,\n blink: `${openANSI}25${closeANSI}`,\n reverse: `${openANSI}27${closeANSI}`,",
"score": 0.8032628297805786
}
] |
typescript
|
format = (message: string, formatConfig: FormatConfig = defaultFormatConfig): string => {
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
|
const insertReturnTransformMapper = new TableMapper(db, 'users', {
|
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
|
src/tests/insert-transforms.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " expect(readUsers.length).toEqual(3);\n for (let i = 0; i < USERS.length; i++) {\n expect(readUsers[i].handle).toEqual(USERS[i].handle);\n }\n });\n it('inserts multiple explicitly returning no columns', async () => {\n const insertReturns = await userMapperReturningNothing\n .insert()\n .returnAll(USERS);\n expect(insertReturns).toBeUndefined();",
"score": 0.9209319353103638
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " user2\n );\n expect(count).toEqual(1);\n const readUser = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser).toEqual(\n User.create(insertReturns[2].id, {\n ...expectedReturn1,\n handle: user3.handle,",
"score": 0.9170252084732056
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " user1\n );\n const expectedReturn3 = {\n id: insertReturns[2].id,\n firstName: user1.firstName,\n lastName: user1.lastName,\n };\n expect(success1).toBe(true);\n // verify updates\n const readUsers = await transformMapper.select().returnAll();",
"score": 0.9117387533187866
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " expect(readUsers[1].email).toEqual(null);\n });\n it('compiles a returning insert query without transformation', async () => {\n const compilation = userMapperReturningAll\n .insert()\n .columns(['name', 'handle', 'email'])\n .compile();\n // test returnOne()\n const insertReturn = await compilation.returnOne(USERS[0]);\n expect(insertReturn).toEqual({ ...USERS[0], id: 1 });",
"score": 0.9115867614746094
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " expect(count).toEqual(1);\n const readUser4 = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser4).toEqual(expectedUser2);\n ignore('check compile-time types', async () => {\n // @ts-expect-error - only update objects are allowed\n compilation.returnOne({}, USERS[0]);\n // @ts-expect-error - only update objects are allowed\n compilation.returnAll({}, USERS[0]);",
"score": 0.9085255861282349
}
] |
typescript
|
const insertReturnTransformMapper = new TableMapper(db, 'users', {
|
import { effectReset, forgroundRGBColor } from "#/colors";
import { FormatConfig } from "./formatter.type";
import { RGB, isInRGBRange, isRGBValues, removeEscapeSequence } from "#/utils/color";
import { defaultFormatConfig, defaultRainbowStartColor } from "./formatter.const";
import { charIndexes, concatCharIndexes, linearGradientIndex, nextRGBValue } from "./formatter.util";
export const linearGradient = (message: string, start: RGB, end: RGB, ignoreSpaces = true): string => {
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values (start). Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
if (!isRGBValues(end)) {
throw new Error(`Invalid RGB values (end). Values must be in [0, 255]: red=\`${end.red}\`, green=\`${end.green}\`, blue=\`${end.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
if (tempMessage.length <= 1) {
newMessage.push(`${forgroundRGBColor(start)}${tempMessage}`);
} else {
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
continue;
}
const color = linearGradientIndex(start, end, (i / (tempMessage.length - 1)));
newMessage.push(`${forgroundRGBColor(color)}${tempMessage[i]}`);
}
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
export const matrix = (message: string, color: RGB, force = 100): string => {
if (!isRGBValues(color)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${color.red}\`, green=\`${color.green}\`, blue=\`${color.blue}\``);
}
if (!isInRGBRange(force)) throw new Error(`Invalid force. Value must be in [0, 255]: force=\`${force}\``);
message = removeEscapeSequence(message);
let newMessage = "";
for (let i = 0; i < message.length; i++) {
if (message[i] === " ") {
newMessage += message[i];
continue;
}
const num = Math.round(Math.random() * force); // Random number between 0 and force
// For each value cross-product
const colorNuance: RGB = {
red: Math.floor(color.red * ((255 - num) / 255)),
green: Math.floor(color.green * ((255 - num) / 255)),
blue: Math.floor(color.blue * ((255 - num) / 255))
};
newMessage += `${forgroundRGBColor(colorNuance)}${message[i]}`;
}
return `${newMessage}${effectReset.all}`;
};
export const rainbow = (message: string, start: RGB = defaultRainbowStartColor, step = 15, ignoreSpaces = true): string => {
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
let nextColor = start;
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
} else {
newMessage.push(`${forgroundRGBColor(nextColor)}${tempMessage[i]}`);
}
nextColor = nextRGBValue(nextColor, step);
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
export const format = (message: string, formatConfig: FormatConfig = defaultFormatConfig): string => {
const regex = new RegExp(Object.keys(formatConfig).join("|"), "g");
return message.replace(
|
regex, match => formatConfig[match]);
|
};
|
src/formatters/formatter.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " ...defaultFormatConfig,\n \"§1\": forground.black,\n \"§2\": `§${forground.red}`,\n \"§3\": `§${forground.green}`,\n \"§4\": `§${forground.yellow}`\n };\n expect(format(\"\", formatConfig)).toBe(\"\");\n expect(format(\"a\", formatConfig)).toBe(\"a\");\n expect(format(\"aa\", formatConfig)).toBe(\"aa\");\n expect(format(\"§2aa\", formatConfig)).toBe(\"§\\u001B[31maa\");",
"score": 0.8362557888031006
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " };\n expect(format(\"\", formatConfig)).toBe(\"\");\n expect(format(\"a\", formatConfig)).toBe(\"a\");\n expect(format(\"aa\", formatConfig)).toBe(\"aa\");\n expect(format(\"§2aa\", formatConfig)).toBe(\"§\\u001B[31maa\");\n expect(format(\"§a2a\", formatConfig)).toBe(\"§a2a\");\n expect(format(\"§2§baa\", formatConfig)).toBe(\"§\\u001B[31m§baa\");\n });\n it(\"should return a formatted string with custom & default values passed in parameters replace by their replacement\", () => {\n const formatConfig: FormatConfig = {",
"score": 0.8286740779876709
},
{
"filename": "src/colors/colors.const.ts",
"retrieved_chunk": " strikethrough: `${openANSI}9${closeANSI}`\n} as const;\nexport const effectReset = {\n all: `${openANSI}0${closeANSI}`,\n bold: `${openANSI}22${closeANSI}`,\n thin: `${openANSI}22${closeANSI}`,\n italic: `${openANSI}23${closeANSI}`,\n underline: `${openANSI}24${closeANSI}`,\n blink: `${openANSI}25${closeANSI}`,\n reverse: `${openANSI}27${closeANSI}`,",
"score": 0.8200218677520752
},
{
"filename": "src/formatters/formatter.const.ts",
"retrieved_chunk": "import { FormatConfig } from \"./formatter.type\";\nimport { RGB } from \"#/utils/color\";\nimport { effect, effectReset, forground } from \"#/colors\";\nexport const defaultRainbowStartColor: RGB = {\n red: 255,\n green: 0,\n blue: 0\n} as const;\nexport const defaultFormatConfig: FormatConfig = {\n \"§0\": forground.black,",
"score": 0.8154891133308411
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " expect(format(\"§a2a\", formatConfig)).toBe(\"§a2a\");\n expect(format(\"§2§baa\", formatConfig)).toBe(\"§\\u001B[31m\\u001B[1maa\");\n });\n});",
"score": 0.8101018667221069
}
] |
typescript
|
regex, match => formatConfig[match]);
|
import { background256Color, backgroundRGBColor, forground256Color, forgroundRGBColor } from "../colors";
import { describe, expect, it } from "vitest";
describe("`forgroundRGBColor` function", () => {
it("should return an escape sequence", () => {
expect(forgroundRGBColor({ red: 0, green: 0, blue: 0 })).toBe("\x1b[38;2;0;0;0m");
expect(forgroundRGBColor({ red: 255, green: 255, blue: 255 })).toBe("\x1b[38;2;255;255;255m");
expect(forgroundRGBColor({ red: 0, green: 1, blue: 1 })).toBe("\x1b[38;2;0;1;1m");
expect(forgroundRGBColor({ red: 1, green: 0, blue: 1 })).toBe("\x1b[38;2;1;0;1m");
expect(forgroundRGBColor({ red: 1, green: 1, blue: 0 })).toBe("\x1b[38;2;1;1;0m");
});
it("should throw an error", () => {
expect(() => forgroundRGBColor({ red: -1, green: -1, blue: -1 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`-1`, blue=`-1`");
expect(() => forgroundRGBColor({ red: 256, green: 256, blue: 256 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`256`, green=`256`, blue=`256`");
expect(() => forgroundRGBColor({ red: -1, green: 0, blue: 0 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => forgroundRGBColor({ red: 0, green: -1, blue: 0 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => forgroundRGBColor({ red: 0, green: 0, blue: -1 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
});
});
describe("`backgroundRGBColor` function", () => {
it("should return an escape sequence", () => {
expect(backgroundRGBColor({ red: 0, green: 0, blue: 0 })).toBe("\x1b[48;2;0;0;0m");
expect(backgroundRGBColor({ red: 255, green: 255, blue: 255 })).toBe("\x1b[48;2;255;255;255m");
expect(backgroundRGBColor({ red: 0, green: 1, blue: 1 })).toBe("\x1b[48;2;0;1;1m");
expect(backgroundRGBColor({ red: 1, green: 0, blue: 1 })).toBe("\x1b[48;2;1;0;1m");
expect(backgroundRGBColor({ red: 1, green: 1, blue: 0 })).toBe("\x1b[48;2;1;1;0m");
});
it("should throw an error", () => {
expect(() => backgroundRGBColor({ red: -1, green: -1, blue: -1 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`-1`, blue=`-1`");
expect(() => backgroundRGBColor({ red: 256, green: 256, blue: 256 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`256`, green=`256`, blue=`256`");
expect(() => backgroundRGBColor({ red: -1, green: 0, blue: 0 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => backgroundRGBColor({ red: 0, green: -1, blue: 0 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => backgroundRGBColor({ red: 0, green: 0, blue: -1 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
});
});
describe("`forground256Color` function", () => {
it("should return an escape sequence", () => {
expect
|
(forground256Color(0)).toBe("\x1b[38;5;0m");
|
expect(forground256Color(128)).toBe("\x1b[38;5;128m");
expect(forground256Color(255)).toBe("\x1b[38;5;255m");
});
it("should throw an error", () => {
expect(() => forground256Color(-1)).toThrow("Invalid colorId. Value must be in [0, 255]: colorId=`-1`");
expect(() => forground256Color(256)).toThrow("Invalid colorId. Value must be in [0, 255]: colorId=`256`");
});
});
describe("`backround256Color` function", () => {
it("should return an escape sequence", () => {
expect(background256Color(0)).toBe("\x1b[48;5;0m");
expect(background256Color(128)).toBe("\x1b[48;5;128m");
expect(background256Color(255)).toBe("\x1b[48;5;255m");
});
it("should throw an error", () => {
expect(() => background256Color(-1)).toThrow("Invalid colorId. Value must be in [0, 255]: colorId=`-1`");
expect(() => background256Color(256)).toThrow("Invalid colorId. Value must be in [0, 255]: colorId=`256`");
});
});
|
src/colors/_test/color.test.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma\\u001B[0m\");\n expect(rainbow(\"aaa\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma\\u001B[38;2;230;115;176ma\\u001B[0m\");\n expect(rainbow(\"aaaaa\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma\\u001B[38;2;230;115;176ma\\u001B[38;2;230;204;115ma\\u001B[38;2;115;230;124ma\\u001B[0m\");\n expect(rainbow(\"aa aa\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma \\u001B[38;2;230;115;176ma\\u001B[38;2;230;204;115ma\\u001B[0m\");\n expect(rainbow(\" aa\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\" \\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma\\u001B[0m\");\n });",
"score": 0.8915096521377563
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`\");\n expect(() => rainbow(\"\", { red: 0, green: 0, blue: 256 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`\");\n });\n});\ndescribe(\"`format` function\", () => {\n it(\"should return a formatted string with default values passed in parameters replace by their replacement\", () => {\n expect(format(\"\")).toBe(\"\");\n expect(format(\"a\")).toBe(\"a\");\n expect(format(\"aa\")).toBe(\"aa\");",
"score": 0.8913968205451965
},
{
"filename": "src/utils/color/_test/color.util.test.ts",
"retrieved_chunk": " expect(() => hexToRgb(\"#0000AG\")).toThrow(\"`#0000AG` isn't a hexadecimal color code\");\n expect(() => hexToRgb(\"#0-_\")).toThrow(\"`#0-_` isn't a hexadecimal color code\");\n });\n});\ndescribe(\"`removeEscapeSequence` function\", () => {\n it(\"should return a string without ANSI escape sequences\", () => {\n expect(removeEscapeSequence(\"\\u001B[0ma\")).toBe(\"a\");\n expect(removeEscapeSequence(\"a\\u001B[0ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"\\u001B[0ma\\u001B[0ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0ma\\u001B[0ma\")).toBe(\"aaa\");",
"score": 0.8907259702682495
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toThrow(\"Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`\");\n expect(() => linearGradient(\"\", { red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 256 }))\n .toThrow(\"Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`\");\n });\n});\ndescribe(\"`matrix` function\", () => {\n it(\"should return a formatted string with a random value set to 0\", () => {\n vi.spyOn(global.Math, \"random\").mockReturnValue(0);\n expect(matrix(\"\", { red: 255, green: 128, blue: 0 })).toBe(\"\\u001B[0m\");\n expect(matrix(\"a\", { red: 255, green: 128, blue: 0 })).toBe(\"\\u001B[38;2;255;128;0ma\\u001B[0m\");",
"score": 0.8883408308029175
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " it(\"should throw an error\", () => {\n expect(() => rainbow(\"\", { red: -1, green: 0, blue: 0 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`\");\n expect(() => rainbow(\"\", { red: 0, green: -1, blue: 0 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`\");\n expect(() => rainbow(\"\", { red: 0, green: 0, blue: -1 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`\");\n expect(() => rainbow(\"\", { red: 256, green: 0, blue: 0 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`\");\n expect(() => rainbow(\"\", { red: 0, green: 256, blue: 0 }))",
"score": 0.8870333433151245
}
] |
typescript
|
(forground256Color(0)).toBe("\x1b[38;5;0m");
|
import { effectReset, forgroundRGBColor } from "#/colors";
import { FormatConfig } from "./formatter.type";
import { RGB, isInRGBRange, isRGBValues, removeEscapeSequence } from "#/utils/color";
import { defaultFormatConfig, defaultRainbowStartColor } from "./formatter.const";
import { charIndexes, concatCharIndexes, linearGradientIndex, nextRGBValue } from "./formatter.util";
export const linearGradient = (message: string, start: RGB, end: RGB, ignoreSpaces = true): string => {
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values (start). Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
if (!isRGBValues(end)) {
throw new Error(`Invalid RGB values (end). Values must be in [0, 255]: red=\`${end.red}\`, green=\`${end.green}\`, blue=\`${end.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
if (tempMessage.length <= 1) {
newMessage.push(`${forgroundRGBColor(start)}${tempMessage}`);
} else {
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
continue;
}
const color = linearGradientIndex(start, end, (i / (tempMessage.length - 1)));
newMessage.push(`${forgroundRGBColor(color)}${tempMessage[i]}`);
}
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
export const matrix = (message: string, color: RGB, force = 100): string => {
if (!isRGBValues(color)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${color.red}\`, green=\`${color.green}\`, blue=\`${color.blue}\``);
}
if (!isInRGBRange(force)) throw new Error(`Invalid force. Value must be in [0, 255]: force=\`${force}\``);
message = removeEscapeSequence(message);
let newMessage = "";
for (let i = 0; i < message.length; i++) {
if (message[i] === " ") {
newMessage += message[i];
continue;
}
const num = Math.round(Math.random() * force); // Random number between 0 and force
// For each value cross-product
const colorNuance: RGB = {
red: Math.floor(color.red * ((255 - num) / 255)),
green: Math.floor(color.green * ((255 - num) / 255)),
blue: Math.floor(color.blue * ((255 - num) / 255))
};
newMessage += `${forgroundRGBColor(colorNuance)}${message[i]}`;
}
return `${newMessage}${effectReset.all}`;
};
export const rainbow = (message: string, start: RGB = defaultRainbowStartColor, step = 15, ignoreSpaces = true): string => {
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
let nextColor = start;
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
} else {
newMessage.push(`${forgroundRGBColor(nextColor)}${tempMessage[i]}`);
}
nextColor = nextRGBValue(nextColor, step);
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
|
export const format = (message: string, formatConfig: FormatConfig = defaultFormatConfig): string => {
|
const regex = new RegExp(Object.keys(formatConfig).join("|"), "g");
return message.replace(regex, match => formatConfig[match]);
};
|
src/formatters/formatter.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/formatters/formatter.util.ts",
"retrieved_chunk": " const spaceIndex: number[] = [];\n for (let i = 0; i < message.length; i++) {\n if (message[i] !== char) continue;\n spaceIndex.push(i);\n }\n return spaceIndex;\n};\nexport const concatCharIndexes = (message: string[], charIndexes : number[], char: string): string[] => {\n charIndexes.sort((a, b) => a - b);\n for (const index of charIndexes) {",
"score": 0.8266865015029907
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " ...defaultFormatConfig,\n \"§1\": forground.black,\n \"§2\": `§${forground.red}`,\n \"§3\": `§${forground.green}`,\n \"§4\": `§${forground.yellow}`\n };\n expect(format(\"\", formatConfig)).toBe(\"\");\n expect(format(\"a\", formatConfig)).toBe(\"a\");\n expect(format(\"aa\", formatConfig)).toBe(\"aa\");\n expect(format(\"§2aa\", formatConfig)).toBe(\"§\\u001B[31maa\");",
"score": 0.8173280954360962
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " };\n expect(format(\"\", formatConfig)).toBe(\"\");\n expect(format(\"a\", formatConfig)).toBe(\"a\");\n expect(format(\"aa\", formatConfig)).toBe(\"aa\");\n expect(format(\"§2aa\", formatConfig)).toBe(\"§\\u001B[31maa\");\n expect(format(\"§a2a\", formatConfig)).toBe(\"§a2a\");\n expect(format(\"§2§baa\", formatConfig)).toBe(\"§\\u001B[31m§baa\");\n });\n it(\"should return a formatted string with custom & default values passed in parameters replace by their replacement\", () => {\n const formatConfig: FormatConfig = {",
"score": 0.8163191080093384
},
{
"filename": "src/colors/colors.const.ts",
"retrieved_chunk": " strikethrough: `${openANSI}9${closeANSI}`\n} as const;\nexport const effectReset = {\n all: `${openANSI}0${closeANSI}`,\n bold: `${openANSI}22${closeANSI}`,\n thin: `${openANSI}22${closeANSI}`,\n italic: `${openANSI}23${closeANSI}`,\n underline: `${openANSI}24${closeANSI}`,\n blink: `${openANSI}25${closeANSI}`,\n reverse: `${openANSI}27${closeANSI}`,",
"score": 0.8008254170417786
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " expect(format(\"§a2a\", formatConfig)).toBe(\"§a2a\");\n expect(format(\"§2§baa\", formatConfig)).toBe(\"§\\u001B[31m\\u001B[1maa\");\n });\n});",
"score": 0.7990304827690125
}
] |
typescript
|
export const format = (message: string, formatConfig: FormatConfig = defaultFormatConfig): string => {
|
import { charIndexes, concatCharIndexes, linearGradientIndex, nextRGBValue } from "../formatter.util";
import { RGB } from "#/utils/color";
import { describe, expect, it } from "vitest";
describe("`linearGradientIndex` function", () => {
it("should return a RGB value", () => {
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0))
.toStrictEqual<RGB>({ red: 255, green: 0, blue: 112 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.2))
.toStrictEqual<RGB>({ red: 209, green: 48, blue: 94 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.4))
.toStrictEqual<RGB>({ red: 163, green: 96, blue: 76 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.6))
.toStrictEqual<RGB>({ red: 117, green: 144, blue: 58 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.8))
.toStrictEqual<RGB>({ red: 71, green: 192, blue: 40 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 1))
.toStrictEqual<RGB>({ red: 25, green: 240, blue: 22 });
});
it("should throw an error", () => {
expect(() => linearGradientIndex({ red: -1, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: -1, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: -1 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
expect(() => linearGradientIndex({ red: 256, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 256, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 256 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: -1, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: -1, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: -1 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 256, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 256, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 256 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, -1))
.toThrow("Index must be in range [0,1]: index=`-1`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, 2))
.toThrow("Index must be in range [0,1]: index=`2`");
});
});
describe("`nextRGBValue` function", () => {
it("should return a RGB value", () => {
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 0))
.toStrictEqual<RGB>({ red: 255, green: 0, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 1530))
.toStrictEqual<RGB>({ red: 255, green: 0, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 10))
.toStrictEqual<RGB>({ red: 255, green: 10, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 50))
.toStrictEqual<RGB>({ red: 255, green: 50, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 100))
.toStrictEqual<RGB>({ red: 255, green: 100, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 500))
.toStrictEqual<RGB>({ red: 10, green: 255, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 1000))
.toStrictEqual<RGB>({ red: 0, green: 20, blue: 255 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 0))
.toStrictEqual<RGB>({ red: 47, green: 61, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 1248))
.toStrictEqual<RGB>({ red: 47, green: 61, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 1530))
.toStrictEqual<RGB>({ red: 49, green: 74, blue: 47 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 10))
.toStrictEqual<RGB>({ red: 47, green: 51, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 50))
.toStrictEqual<RGB>({ red: 74, green: 47, blue: 65 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 100))
.toStrictEqual<RGB>({ red: 69, green: 74, blue: 47 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 500))
.toStrictEqual<RGB>({ red: 47, green: 47, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 1000))
.toStrictEqual<RGB>({ red: 61, green: 47, blue: 74 });
});
it("should throw an error", () => {
expect(() => nextRGBValue({ red: -1, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: -1, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: 0, blue: -1 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
expect(() => nextRGBValue({ red: 256, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: 256, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: 0, blue: 256 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`");
});
});
describe("`charIndexes` function", () => {
it("should return an array of indexes", () => {
expect(charIndexes("", " ")).toStrictEqual([]);
expect(charIndexes("foo", " ")).toStrictEqual([]);
expect(charIndexes("foo bar", " ")).toStrictEqual([3]);
expect(charIndexes("foo bar", " ")).toStrictEqual([3]);
expect(charIndexes("foo bar", " ")).toStrictEqual([3]);
expect(charIndexes("foo bar toto titi tata tutu tete", " ")).toStrictEqual([3, 7, 12, 17, 22, 27]);
expect(charIndexes("foo bar toto titi tata tutu tete", "a")).toStrictEqual([5, 19, 21]);
});
});
describe("`concatCharIndexes` function", () => {
it("should return an array of string", () => {
expect
|
(concatCharIndexes([], [], "foo")).toStrictEqual([]);
|
expect(concatCharIndexes([], [1], "foo")).toStrictEqual(["foo"]);
expect(concatCharIndexes(["bar"], [], "foo")).toStrictEqual(["bar"]);
expect(concatCharIndexes(["bar"], [0], "foo")).toStrictEqual(["foo", "bar"]);
expect(concatCharIndexes(["bar"], [1], "foo")).toStrictEqual(["bar", "foo"]);
expect(concatCharIndexes(["bar"], [0, 3], "foo")).toStrictEqual(["foo", "bar", "foo"]);
expect(concatCharIndexes(["bar"], [1, 3], "foo")).toStrictEqual(["bar", "foo", "foo"]);
expect(concatCharIndexes(["bar", "toto", "titi", "tata", "tutu", "tete"], [1, 19, 3, 8], "foo"))
.toStrictEqual(["bar", "foo", "toto", "foo", "titi", "tata", "tutu", "tete", "foo", "foo"]);
});
});
|
src/formatters/_test/formatter.util.test.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/formatters/formatter.util.ts",
"retrieved_chunk": " const spaceIndex: number[] = [];\n for (let i = 0; i < message.length; i++) {\n if (message[i] !== char) continue;\n spaceIndex.push(i);\n }\n return spaceIndex;\n};\nexport const concatCharIndexes = (message: string[], charIndexes : number[], char: string): string[] => {\n charIndexes.sort((a, b) => a - b);\n for (const index of charIndexes) {",
"score": 0.8591787815093994
},
{
"filename": "src/utils/color/_test/color.util.test.ts",
"retrieved_chunk": " expect(removeEscapeSequence(\"a\\u001B[0;1ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0;1;12ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0;1;12;123ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0;1;12;123;1234ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0;1;12;123;1234;1345ma\")).toBe(\"aa\");\n });\n});",
"score": 0.797033429145813
},
{
"filename": "src/formatters/formatter.util.ts",
"retrieved_chunk": " remainingSteps -= valueToRemove;\n }\n }\n return {\n red: colorsArray[0].color,\n green: colorsArray[1].color,\n blue: colorsArray[2].color\n };\n};\nexport const charIndexes = (message: string, char: string): number[] => {",
"score": 0.7925615906715393
},
{
"filename": "src/utils/color/_test/color.util.test.ts",
"retrieved_chunk": " expect(() => hexToRgb(\"#0000AG\")).toThrow(\"`#0000AG` isn't a hexadecimal color code\");\n expect(() => hexToRgb(\"#0-_\")).toThrow(\"`#0-_` isn't a hexadecimal color code\");\n });\n});\ndescribe(\"`removeEscapeSequence` function\", () => {\n it(\"should return a string without ANSI escape sequences\", () => {\n expect(removeEscapeSequence(\"\\u001B[0ma\")).toBe(\"a\");\n expect(removeEscapeSequence(\"a\\u001B[0ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"\\u001B[0ma\\u001B[0ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0ma\\u001B[0ma\")).toBe(\"aaa\");",
"score": 0.7899774312973022
},
{
"filename": "src/colors/_test/color.test.ts",
"retrieved_chunk": " it(\"should throw an error\", () => {\n expect(() => forground256Color(-1)).toThrow(\"Invalid colorId. Value must be in [0, 255]: colorId=`-1`\");\n expect(() => forground256Color(256)).toThrow(\"Invalid colorId. Value must be in [0, 255]: colorId=`256`\");\n });\n});\ndescribe(\"`backround256Color` function\", () => {\n it(\"should return an escape sequence\", () => {\n expect(background256Color(0)).toBe(\"\\x1b[48;5;0m\");\n expect(background256Color(128)).toBe(\"\\x1b[48;5;128m\");\n expect(background256Color(255)).toBe(\"\\x1b[48;5;255m\");",
"score": 0.7867571115493774
}
] |
typescript
|
(concatCharIndexes([], [], "foo")).toStrictEqual([]);
|
import { background256Color, backgroundRGBColor, forground256Color, forgroundRGBColor } from "../colors";
import { describe, expect, it } from "vitest";
describe("`forgroundRGBColor` function", () => {
it("should return an escape sequence", () => {
expect(forgroundRGBColor({ red: 0, green: 0, blue: 0 })).toBe("\x1b[38;2;0;0;0m");
expect(forgroundRGBColor({ red: 255, green: 255, blue: 255 })).toBe("\x1b[38;2;255;255;255m");
expect(forgroundRGBColor({ red: 0, green: 1, blue: 1 })).toBe("\x1b[38;2;0;1;1m");
expect(forgroundRGBColor({ red: 1, green: 0, blue: 1 })).toBe("\x1b[38;2;1;0;1m");
expect(forgroundRGBColor({ red: 1, green: 1, blue: 0 })).toBe("\x1b[38;2;1;1;0m");
});
it("should throw an error", () => {
expect(() => forgroundRGBColor({ red: -1, green: -1, blue: -1 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`-1`, blue=`-1`");
expect(() => forgroundRGBColor({ red: 256, green: 256, blue: 256 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`256`, green=`256`, blue=`256`");
expect(() => forgroundRGBColor({ red: -1, green: 0, blue: 0 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => forgroundRGBColor({ red: 0, green: -1, blue: 0 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => forgroundRGBColor({ red: 0, green: 0, blue: -1 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
});
});
describe("`backgroundRGBColor` function", () => {
it("should return an escape sequence", () => {
expect(backgroundRGBColor({ red: 0, green: 0, blue: 0 })).toBe("\x1b[48;2;0;0;0m");
expect(backgroundRGBColor({ red: 255, green: 255, blue: 255 })).toBe("\x1b[48;2;255;255;255m");
expect(backgroundRGBColor({ red: 0, green: 1, blue: 1 })).toBe("\x1b[48;2;0;1;1m");
expect(backgroundRGBColor({ red: 1, green: 0, blue: 1 })).toBe("\x1b[48;2;1;0;1m");
expect(backgroundRGBColor({ red: 1, green: 1, blue: 0 })).toBe("\x1b[48;2;1;1;0m");
});
it("should throw an error", () => {
expect(() => backgroundRGBColor({ red: -1, green: -1, blue: -1 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`-1`, blue=`-1`");
expect(() => backgroundRGBColor({ red: 256, green: 256, blue: 256 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`256`, green=`256`, blue=`256`");
expect(() => backgroundRGBColor({ red: -1, green: 0, blue: 0 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => backgroundRGBColor({ red: 0, green: -1, blue: 0 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => backgroundRGBColor({ red: 0, green: 0, blue: -1 }))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
});
});
describe("`forground256Color` function", () => {
it("should return an escape sequence", () => {
expect(forground256Color(0)).toBe("\x1b[38;5;0m");
expect(forground256Color(128)).toBe("\x1b[38;5;128m");
expect(forground256Color(255)).toBe("\x1b[38;5;255m");
});
it("should throw an error", () => {
expect(() => forground256Color(-1)).toThrow("Invalid colorId. Value must be in [0, 255]: colorId=`-1`");
expect(() => forground256Color(256)).toThrow("Invalid colorId. Value must be in [0, 255]: colorId=`256`");
});
});
describe("`backround256Color` function", () => {
it("should return an escape sequence", () => {
|
expect(background256Color(0)).toBe("\x1b[48;5;0m");
|
expect(background256Color(128)).toBe("\x1b[48;5;128m");
expect(background256Color(255)).toBe("\x1b[48;5;255m");
});
it("should throw an error", () => {
expect(() => background256Color(-1)).toThrow("Invalid colorId. Value must be in [0, 255]: colorId=`-1`");
expect(() => background256Color(256)).toThrow("Invalid colorId. Value must be in [0, 255]: colorId=`256`");
});
});
|
src/colors/_test/color.test.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/colors/colors.ts",
"retrieved_chunk": "};\nexport const background256Color = (colorId: number): Background256 => {\n if (!isInRGBRange(colorId)) {\n throw new Error(`Invalid colorId. Value must be in [0, 255]: colorId=\\`${colorId}\\``);\n }\n return `${openANSI}48;5;${colorId}${closeANSI}`;\n};",
"score": 0.8867732286453247
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma\\u001B[0m\");\n expect(rainbow(\"aaa\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma\\u001B[38;2;230;115;176ma\\u001B[0m\");\n expect(rainbow(\"aaaaa\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma\\u001B[38;2;230;115;176ma\\u001B[38;2;230;204;115ma\\u001B[38;2;115;230;124ma\\u001B[0m\");\n expect(rainbow(\"aa aa\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma \\u001B[38;2;230;115;176ma\\u001B[38;2;230;204;115ma\\u001B[0m\");\n expect(rainbow(\" aa\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\" \\u001B[38;2;115;230;214ma\\u001B[38;2;134;115;230ma\\u001B[0m\");\n });",
"score": 0.8820195198059082
},
{
"filename": "src/colors/colors.ts",
"retrieved_chunk": " if (!isRGBValues(color)) {\n throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\\`${color.red}\\`, green=\\`${color.green}\\`, blue=\\`${color.blue}\\``);\n }\n return `${openANSI}48;2;${color.red};${color.green};${color.blue}${closeANSI}`;\n};\nexport const forground256Color = (colorId: number): Forground256 => {\n if (!isInRGBRange(colorId)) {\n throw new Error(`Invalid colorId. Value must be in [0, 255]: colorId=\\`${colorId}\\``);\n }\n return `${openANSI}38;5;${colorId}${closeANSI}`;",
"score": 0.880879282951355
},
{
"filename": "src/utils/color/_test/color.util.test.ts",
"retrieved_chunk": " expect(() => hexToRgb(\"#0000AG\")).toThrow(\"`#0000AG` isn't a hexadecimal color code\");\n expect(() => hexToRgb(\"#0-_\")).toThrow(\"`#0-_` isn't a hexadecimal color code\");\n });\n});\ndescribe(\"`removeEscapeSequence` function\", () => {\n it(\"should return a string without ANSI escape sequences\", () => {\n expect(removeEscapeSequence(\"\\u001B[0ma\")).toBe(\"a\");\n expect(removeEscapeSequence(\"a\\u001B[0ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"\\u001B[0ma\\u001B[0ma\")).toBe(\"aa\");\n expect(removeEscapeSequence(\"a\\u001B[0ma\\u001B[0ma\")).toBe(\"aaa\");",
"score": 0.8742914199829102
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toBe(\" \\u001B[38;2;255;75;0ma\\u001B[38;2;255;90;0ma\\u001B[0m\");\n });\n it(\"should return a formatted string with ignoring spaces and start at different color\", () => {\n expect(rainbow(\"\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[0m\");\n expect(rainbow(\"a\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[0m\");\n expect(rainbow(\"aa\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma\\u001B[0m\");\n expect(rainbow(\"aaa\", { red: 115, green: 230, blue: 214 }))",
"score": 0.87386155128479
}
] |
typescript
|
expect(background256Color(0)).toBe("\x1b[48;5;0m");
|
import { charIndexes, concatCharIndexes, linearGradientIndex, nextRGBValue } from "../formatter.util";
import { RGB } from "#/utils/color";
import { describe, expect, it } from "vitest";
describe("`linearGradientIndex` function", () => {
it("should return a RGB value", () => {
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0))
.toStrictEqual<RGB>({ red: 255, green: 0, blue: 112 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.2))
.toStrictEqual<RGB>({ red: 209, green: 48, blue: 94 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.4))
.toStrictEqual<RGB>({ red: 163, green: 96, blue: 76 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.6))
.toStrictEqual<RGB>({ red: 117, green: 144, blue: 58 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 0.8))
.toStrictEqual<RGB>({ red: 71, green: 192, blue: 40 });
expect(linearGradientIndex({ red: 255, green: 0, blue: 112 }, { red: 25, green: 240, blue: 22 }, 1))
.toStrictEqual<RGB>({ red: 25, green: 240, blue: 22 });
});
it("should throw an error", () => {
expect(() => linearGradientIndex({ red: -1, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: -1, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: -1 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
expect(() => linearGradientIndex({ red: 256, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 256, blue: 0 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 256 }, { red: 0, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (start). Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: -1, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: -1, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: -1 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 256, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 256, blue: 0 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 256 }, 0))
.toThrow("Invalid RGB values (end). Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, -1))
.toThrow("Index must be in range [0,1]: index=`-1`");
expect(() => linearGradientIndex({ red: 0, green: 0, blue: 0 }, { red: 0, green: 0, blue: 0 }, 2))
.toThrow("Index must be in range [0,1]: index=`2`");
});
});
describe("`nextRGBValue` function", () => {
it("should return a RGB value", () => {
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 0))
.toStrictEqual<RGB>({ red: 255, green: 0, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 1530))
.toStrictEqual<RGB>({ red: 255, green: 0, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 10))
.toStrictEqual<RGB>({ red: 255, green: 10, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 50))
.toStrictEqual<RGB>({ red: 255, green: 50, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 100))
.toStrictEqual<RGB>({ red: 255, green: 100, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 500))
.toStrictEqual<RGB>({ red: 10, green: 255, blue: 0 });
expect(nextRGBValue({ red: 255, green: 0, blue: 0 }, 1000))
.toStrictEqual<RGB>({ red: 0, green: 20, blue: 255 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 0))
.toStrictEqual<RGB>({ red: 47, green: 61, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 1248))
.toStrictEqual<RGB>({ red: 47, green: 61, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 1530))
.toStrictEqual<RGB>({ red: 49, green: 74, blue: 47 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 10))
.toStrictEqual<RGB>({ red: 47, green: 51, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 50))
.toStrictEqual<RGB>({ red: 74, green: 47, blue: 65 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 100))
.toStrictEqual<RGB>({ red: 69, green: 74, blue: 47 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 500))
.toStrictEqual<RGB>({ red: 47, green: 47, blue: 74 });
expect(nextRGBValue({ red: 47, green: 61, blue: 74 }, 1000))
.toStrictEqual<RGB>({ red: 61, green: 47, blue: 74 });
});
it("should throw an error", () => {
expect(() => nextRGBValue({ red: -1, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: -1, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: 0, blue: -1 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`");
expect(() => nextRGBValue({ red: 256, green: 0, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: 256, blue: 0 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`");
expect(() => nextRGBValue({ red: 0, green: 0, blue: 256 }, 0))
.toThrow("Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`");
});
});
describe("`charIndexes` function", () => {
it("should return an array of indexes", () => {
|
expect(charIndexes("", " ")).toStrictEqual([]);
|
expect(charIndexes("foo", " ")).toStrictEqual([]);
expect(charIndexes("foo bar", " ")).toStrictEqual([3]);
expect(charIndexes("foo bar", " ")).toStrictEqual([3]);
expect(charIndexes("foo bar", " ")).toStrictEqual([3]);
expect(charIndexes("foo bar toto titi tata tutu tete", " ")).toStrictEqual([3, 7, 12, 17, 22, 27]);
expect(charIndexes("foo bar toto titi tata tutu tete", "a")).toStrictEqual([5, 19, 21]);
});
});
describe("`concatCharIndexes` function", () => {
it("should return an array of string", () => {
expect(concatCharIndexes([], [], "foo")).toStrictEqual([]);
expect(concatCharIndexes([], [1], "foo")).toStrictEqual(["foo"]);
expect(concatCharIndexes(["bar"], [], "foo")).toStrictEqual(["bar"]);
expect(concatCharIndexes(["bar"], [0], "foo")).toStrictEqual(["foo", "bar"]);
expect(concatCharIndexes(["bar"], [1], "foo")).toStrictEqual(["bar", "foo"]);
expect(concatCharIndexes(["bar"], [0, 3], "foo")).toStrictEqual(["foo", "bar", "foo"]);
expect(concatCharIndexes(["bar"], [1, 3], "foo")).toStrictEqual(["bar", "foo", "foo"]);
expect(concatCharIndexes(["bar", "toto", "titi", "tata", "tutu", "tete"], [1, 19, 3, 8], "foo"))
.toStrictEqual(["bar", "foo", "toto", "foo", "titi", "tata", "tutu", "tete", "foo", "foo"]);
});
});
|
src/formatters/_test/formatter.util.test.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/colors/_test/color.test.ts",
"retrieved_chunk": " expect(() => backgroundRGBColor({ red: 0, green: 0, blue: -1 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`\");\n });\n});\ndescribe(\"`forground256Color` function\", () => {\n it(\"should return an escape sequence\", () => {\n expect(forground256Color(0)).toBe(\"\\x1b[38;5;0m\");\n expect(forground256Color(128)).toBe(\"\\x1b[38;5;128m\");\n expect(forground256Color(255)).toBe(\"\\x1b[38;5;255m\");\n });",
"score": 0.8635851144790649
},
{
"filename": "src/colors/_test/color.test.ts",
"retrieved_chunk": " .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`\");\n });\n});\ndescribe(\"`backgroundRGBColor` function\", () => {\n it(\"should return an escape sequence\", () => {\n expect(backgroundRGBColor({ red: 0, green: 0, blue: 0 })).toBe(\"\\x1b[48;2;0;0;0m\");\n expect(backgroundRGBColor({ red: 255, green: 255, blue: 255 })).toBe(\"\\x1b[48;2;255;255;255m\");\n expect(backgroundRGBColor({ red: 0, green: 1, blue: 1 })).toBe(\"\\x1b[48;2;0;1;1m\");\n expect(backgroundRGBColor({ red: 1, green: 0, blue: 1 })).toBe(\"\\x1b[48;2;1;0;1m\");\n expect(backgroundRGBColor({ red: 1, green: 1, blue: 0 })).toBe(\"\\x1b[48;2;1;1;0m\");",
"score": 0.8584920167922974
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`256`, blue=`0`\");\n expect(() => rainbow(\"\", { red: 0, green: 0, blue: 256 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`256`\");\n });\n});\ndescribe(\"`format` function\", () => {\n it(\"should return a formatted string with default values passed in parameters replace by their replacement\", () => {\n expect(format(\"\")).toBe(\"\");\n expect(format(\"a\")).toBe(\"a\");\n expect(format(\"aa\")).toBe(\"aa\");",
"score": 0.8538039326667786
},
{
"filename": "src/utils/color/_test/color.validator.test.ts",
"retrieved_chunk": " it(\"should be false\", () => {\n expect(isRGBValues({ red: -1, green: -1, blue: -1 })).toBeFalsy();\n expect(isRGBValues({ red: 256, green: 256, blue: 256 })).toBeFalsy();\n expect(isRGBValues({ red: -1, green: 0, blue: 0 })).toBeFalsy();\n expect(isRGBValues({ red: 0, green: -1, blue: 0 })).toBeFalsy();\n expect(isRGBValues({ red: 0, green: 0, blue: -1 })).toBeFalsy();\n });\n});\ndescribe(\"`isInRGBRange` function\", () => {\n it(\"should be true\", () => {",
"score": 0.8499464392662048
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " it(\"should throw an error\", () => {\n expect(() => rainbow(\"\", { red: -1, green: 0, blue: 0 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`-1`, green=`0`, blue=`0`\");\n expect(() => rainbow(\"\", { red: 0, green: -1, blue: 0 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`-1`, blue=`0`\");\n expect(() => rainbow(\"\", { red: 0, green: 0, blue: -1 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`0`, green=`0`, blue=`-1`\");\n expect(() => rainbow(\"\", { red: 256, green: 0, blue: 0 }))\n .toThrow(\"Invalid RGB values. Values must be in [0, 255]: red=`256`, green=`0`, blue=`0`\");\n expect(() => rainbow(\"\", { red: 0, green: 256, blue: 0 }))",
"score": 0.8465005159378052
}
] |
typescript
|
expect(charIndexes("", " ")).toStrictEqual([]);
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createInsertTransformMapper } from './utils/test-mappers';
import {
userRow1,
userRow2,
userRow3,
insertedUser1,
insertedUser2,
insertedUser3,
insertReturnedUser1,
insertReturnedUser2,
insertReturnedUser3,
} from './utils/test-objects';
import { InsertedUser, ReturnedUser, SelectedUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('inserting with transformation', () => {
it('transforms users for insertion without transforming return', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = await insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = await insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1?.name).toEqual(
`${insertedUser1.firstName} ${insertedUser1.lastName}`
);
await insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = await insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(
`${insertedUser2.firstName} ${insertedUser2.lastName}`
);
expect(readUsers[1].name).toEqual(
`${insertedUser3.firstName} ${insertedUser3.lastName}`
);
});
it('transforms insertion return into object without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(
returns.id,
names[0],
names[1],
source.handle,
source.email || null
);
},
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// test that updates return table rows
const updatedUser = await insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_: string) => {})(updatedUser!.name);
});
it('transforms insertion return into primitive without transforming insertion', async () => {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = await insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturn);
const insertReturns = await insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_: number) => {})(insertReturns[0]);
});
it("transforms insertion and insertion return, columns is ['*']", async () => {
expect.assertions(5);
const insertAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source: InsertedUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
countTransform: (count) => Number(count),
});
const insertReturn = await insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturn.firstName);
const insertReturns = await insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_: string) => {})(insertReturns[0].firstName);
});
it('returns SelectedObject with updates returning rows', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform:
|
(source, results) => {
|
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (
source: SelectedUser | Updateable<Database['users']>
) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = await transformMapper.insert().returnOne(userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturn.firstName);
const readUser = await transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = await transformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_: string) => {})(insertReturns[0].firstName);
((_: string) => {})(insertReturns[1].firstName);
const readUsers = await transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = await transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_: string) => {})(updateReturn!.name);
});
});
|
src/tests/insert-transforms.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(updateReturn1!.firstName);\n const readUser1 = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser1).toEqual(expectedUser1);\n // test returnAll()\n const updateReturn2 = await compilation.returnAll({}, user2);\n const expectedUser2 = User.create(insertReturns[2].id, {\n firstName: user2.firstName,",
"score": 0.9264201521873474
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " ),\n ]);\n // Ensure the returned value is accessible as a ReturnedUser\n ((_: string) => {})(updateReturn[0].firstName);\n });\n it('transforms a union of updating object types', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['id'],\n }).withTransforms({\n updateTransform: (source: UpdatingUser | Updateable<Users>) =>",
"score": 0.9223524332046509
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " name: 'Suzanne Smith',\n }),\n ]);\n });\n it('transforms update return into object without transforming update', async () => {\n const updateReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateReturnTransform: (source, returns) =>",
"score": 0.9174083471298218
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " ((_: string) => {})(updateReturns[0].name);\n ignore('type errors', () => {\n // @ts-expect-error - check return types\n insertReturns[0].name;\n // @ts-expect-error - check return types\n updateReturns[0].id;\n });\n });\n it('inserts multiple configured to return all columns', async () => {\n const insertReturns = await userMapperReturningAll",
"score": 0.9171507358551025
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " it('parameterizes an update query with transformation', async () => {\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({",
"score": 0.9162112474441528
}
] |
typescript
|
(source, results) => {
|
import { effectReset, forgroundRGBColor } from "#/colors";
import { FormatConfig } from "./formatter.type";
import { RGB, isInRGBRange, isRGBValues, removeEscapeSequence } from "#/utils/color";
import { defaultFormatConfig, defaultRainbowStartColor } from "./formatter.const";
import { charIndexes, concatCharIndexes, linearGradientIndex, nextRGBValue } from "./formatter.util";
export const linearGradient = (message: string, start: RGB, end: RGB, ignoreSpaces = true): string => {
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values (start). Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
if (!isRGBValues(end)) {
throw new Error(`Invalid RGB values (end). Values must be in [0, 255]: red=\`${end.red}\`, green=\`${end.green}\`, blue=\`${end.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
if (tempMessage.length <= 1) {
newMessage.push(`${forgroundRGBColor(start)}${tempMessage}`);
} else {
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
continue;
}
const color = linearGradientIndex(start, end, (i / (tempMessage.length - 1)));
newMessage.push(`${forgroundRGBColor(color)}${tempMessage[i]}`);
}
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
export const matrix = (message: string, color: RGB, force = 100): string => {
if (!isRGBValues(color)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${color.red}\`, green=\`${color.green}\`, blue=\`${color.blue}\``);
}
if (!isInRGBRange(force)) throw new Error(`Invalid force. Value must be in [0, 255]: force=\`${force}\``);
message = removeEscapeSequence(message);
let newMessage = "";
for (let i = 0; i < message.length; i++) {
if (message[i] === " ") {
newMessage += message[i];
continue;
}
const num = Math.round(Math.random() * force); // Random number between 0 and force
// For each value cross-product
const colorNuance: RGB = {
red: Math.floor(color.red * ((255 - num) / 255)),
green: Math.floor(color.green * ((255 - num) / 255)),
blue: Math.floor(color.blue * ((255 - num) / 255))
};
newMessage += `${forgroundRGBColor(colorNuance)}${message[i]}`;
}
return `${newMessage}${effectReset.all}`;
};
|
export const rainbow = (message: string, start: RGB = defaultRainbowStartColor, step = 15, ignoreSpaces = true): string => {
|
if (!isRGBValues(start)) {
throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\`${start.red}\`, green=\`${start.green}\`, blue=\`${start.blue}\``);
}
message = removeEscapeSequence(message);
const tempMessage = ignoreSpaces ? message.replaceAll(" ", "") : message;
let newMessage: string[] = [];
let nextColor = start;
for (let i = 0; i < tempMessage.length; i++) {
if (tempMessage[i] === " ") {
newMessage.push(tempMessage[i]);
} else {
newMessage.push(`${forgroundRGBColor(nextColor)}${tempMessage[i]}`);
}
nextColor = nextRGBValue(nextColor, step);
}
if (ignoreSpaces) {
newMessage = concatCharIndexes(
newMessage,
charIndexes(message, " "),
" "
);
}
return `${newMessage.join("")}${effectReset.all}`;
};
export const format = (message: string, formatConfig: FormatConfig = defaultFormatConfig): string => {
const regex = new RegExp(Object.keys(formatConfig).join("|"), "g");
return message.replace(regex, match => formatConfig[match]);
};
|
src/formatters/formatter.ts
|
Unarray-Tintify-d96cf71
|
[
{
"filename": "src/formatters/formatter.util.ts",
"retrieved_chunk": " red: Math.floor(start.red + (end.red - start.red) * index),\n green: Math.floor(start.green + (end.green - start.green) * index),\n blue: Math.floor(start.blue + (end.blue - start.blue) * index)\n };\n};\nexport const nextRGBValue = (color: RGB, step: number): RGB => {\n if (!isRGBValues(color)) {\n throw new Error(`Invalid RGB values. Values must be in [0, 255]: red=\\`${color.red}\\`, green=\\`${color.green}\\`, blue=\\`${color.blue}\\``);\n }\n const maxStep = (255 - Math.min(color.red, color.green, color.blue)) * 6; // Max different RGB values",
"score": 0.8326810598373413
},
{
"filename": "src/formatters/formatter.const.ts",
"retrieved_chunk": "import { FormatConfig } from \"./formatter.type\";\nimport { RGB } from \"#/utils/color\";\nimport { effect, effectReset, forground } from \"#/colors\";\nexport const defaultRainbowStartColor: RGB = {\n red: 255,\n green: 0,\n blue: 0\n} as const;\nexport const defaultFormatConfig: FormatConfig = {\n \"§0\": forground.black,",
"score": 0.8303748369216919
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma \\u001B[38;2;115;141;230ma\\u001B[38;2;115;126;230ma\\u001B[0m\");\n expect(rainbow(\" aa\", { red: 115, green: 230, blue: 214 }, undefined, false))\n .toBe(\" \\u001B[38;2;115;171;230ma\\u001B[38;2;115;156;230ma\\u001B[0m\");\n });\n it(\"should return a formatted string with ignoring spaces and have different step\", () => {\n expect(rainbow(\"\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[0m\");\n expect(rainbow(\"a\", { red: 115, green: 230, blue: 214 }, 150))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[0m\");\n expect(rainbow(\"aa\", { red: 115, green: 230, blue: 214 }, 150))",
"score": 0.827398955821991
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toBe(\" \\u001B[38;2;255;75;0ma\\u001B[38;2;255;90;0ma\\u001B[0m\");\n });\n it(\"should return a formatted string with ignoring spaces and start at different color\", () => {\n expect(rainbow(\"\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[0m\");\n expect(rainbow(\"a\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[0m\");\n expect(rainbow(\"aa\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma\\u001B[0m\");\n expect(rainbow(\"aaa\", { red: 115, green: 230, blue: 214 }))",
"score": 0.8225290775299072
},
{
"filename": "src/formatters/_test/formatter.test.ts",
"retrieved_chunk": " .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma\\u001B[38;2;115;216;230ma\\u001B[0m\");\n expect(rainbow(\"aaaaa\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma\\u001B[38;2;115;216;230ma\\u001B[38;2;115;201;230ma\\u001B[38;2;115;186;230ma\\u001B[0m\");\n expect(rainbow(\"aa aa\", { red: 115, green: 230, blue: 214 }))\n .toBe(\"\\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma \\u001B[38;2;115;216;230ma\\u001B[38;2;115;201;230ma\\u001B[0m\");\n expect(rainbow(\" aa\", { red: 115, green: 230, blue: 214 }))\n .toBe(\" \\u001B[38;2;115;230;214ma\\u001B[38;2;115;230;229ma\\u001B[0m\");\n });\n it(\"should return a formatted string without ignoring spaces and start at different color\", () => {\n expect(rainbow(\"\", { red: 115, green: 230, blue: 214 }, undefined, false))",
"score": 0.8216844797134399
}
] |
typescript
|
export const rainbow = (message: string, start: RGB = defaultRainbowStartColor, step = 15, ignoreSpaces = true): string => {
|
import { Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { User } from './utils/test-types';
import { ignore } from './utils/test-utils';
import { createInsertTransformMapper } from './utils/test-mappers';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('table mapper transform type checks', () => {
ignore('detects invalid select transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid select transform
selectTransform: (user: User) => user,
});
});
ignore('detects invalid insert transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid insert transform
insertTransform: (user: User) => user,
});
});
ignore('detects invalid update transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid update transform
updateTransform: (_user) => ({ noId: 1 }),
});
});
ignore('detects invalid update return transform return', async () => {
const mapper = new TableMapper(db, 'users', { keyColumns: ['id'] });
mapper.withTransforms({
selectTransform: (_user) => new User(1, 'John', 'Doe', 'jdoe', 'x@y.z'),
updateTransform: (user: User) => ({
id: user.id,
name: `${user.firstName} ${user.lastName}`,
|
handle: user.handle,
email: user.email,
}),
updateReturnTransform: (_user, returns) => returns,
});
|
(await mapper
.update({ id: 1 })
// @ts-expect-error - ensure that return type is User
.returnOne(new User(1, 'John', 'Doe', 'jdoe', 'jdoe@abc.def')))!.name;
});
ignore('detects insertion transformation type errors', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().returnOne(USERS[0]);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().run(USERS[0]);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().returnOne(selectedUser1);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().run(selectedUser1);
});
it('accepts readonly transforms', () => {
const transforms = {
countTransform: (count: bigint) => count,
} as const;
new TableMapper(db, 'users', {}).withTransforms(transforms);
});
});
|
src/tests/transform-types.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (user: MappedUser) => ({\n name: `${user.firstName} ${user.lastName}`,\n handle: user.handle,\n email: user.email,\n }),\n insertReturnTransform: (user, returns) =>\n new MappedUser(\n returns.id,",
"score": 0.909458577632904
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " });\n const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');\n const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');\n const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');\n const insertReturns = await transformMapper\n .insert()\n .returnAll([user1, user2, user3]);\n const parameterization = transformMapper.parameterize<{ id: number }>(\n ({ mapper, param }) =>\n mapper.update({ id: param('id') }).columns(['name'])",
"score": 0.9086927175521851
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateTransform: (source: UpdatingUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n });\n const insertReturns = await mapper",
"score": 0.9075437188148499
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " updateReturnColumns: ['*'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,",
"score": 0.9005608558654785
},
{
"filename": "src/tests/utils/test-mappers.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n countTransform: (count) => Number(count),\n });\n}",
"score": 0.8966846466064453
}
] |
typescript
|
handle: user.handle,
email: user.email,
}),
updateReturnTransform: (_user, returns) => returns,
});
|
/**
* Tests TableMapper.selectMany(), TableMapper.selectOne(), and query filters.
*/
import { Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningID(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('general selection', () => {
it('compiles an unparameterized select query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.select({ name: USERS[0].name }).compile();
const users = await compilation.returnAll({});
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
const user = await compilation.returnOne({});
expect(user?.handle).toEqual(USERS[0].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
ignore('compilation type errors', () => {
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
});
});
it('parameterizes and compiles a select query', async () => {
await userMapper.insert().run(USERS);
const parameterization = userMapper.parameterize<{ name: string }>(
({ mapper, param }) => mapper.select({ name: param('name') })
);
// test returnAll() returning multiple
const users = await parameterization.returnAll({ name: USERS[0].name });
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
// test returnAll() returning none
const users2 = await parameterization.returnAll({ name: 'not there' });
expect(users2.length).toEqual(0);
// test returnOne() returning one
const user = await parameterization.returnOne({ name: USERS[1].name });
expect(user?.handle).toEqual(USERS[1].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
// test returnOne() returning none
const user2 = await parameterization.returnOne({ name: 'not there' });
expect(user2).toBeNull();
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ notThere: 'foo' });
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ name: 123 });
});
});
it('modifies the underlying query builder', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[2].handle);
expect(users[1].handle).toEqual(USERS[0].handle);
const user = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnOne();
expect(user?.handle).toEqual(USERS[2].handle);
});
it('does not modify the underlying selected columns', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnAll();
expect(users).toEqual([
{ ...USERS[2], id: 3 },
{ ...USERS[1], id: 2 },
{ ...USERS[0], id: 1 },
]);
// Ensure that columns can be addressed by name.
((_: number) => {})(users[0].id);
((_: string) => {})(users[0].handle);
((_: string) => {})(users[0].name);
((_: string) => {})(users[0].email!);
const user = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnOne();
expect(user).toEqual({ ...USERS[2], id: 3 });
// Ensure that columns can be addressed by name.
((_: number) => {})(user!.id);
((_: string) => {})(user!.handle);
((_: string) => {})(user!.name);
((_: string) => {})(user!.email!);
ignore('detects modify() type errors', async () => {
// @ts-expect-error - cannot access invalid columns
users[0].notThere;
// @ts-expect-error - cannot access invalid columns
user!.notThere;
});
});
it('selects via a multi-column key tuple (definition order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id', 'name'],
});
|
await mapper.insert().run(USERS);
|
const users = await mapper.select([3, 'Sue']).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
it('selects via a multi-column key tuple (different order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['name', 'id'],
});
await mapper.insert().run(USERS);
const users = await mapper.select(['Sue', 3]).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
ignore('detects select(filter) type errors', async () => {
// @ts-expect-error - doesn't allow only two arguments
userMapper.select('name', '=');
// @ts-expect-error - object filter fields must be valid
userMapper.select({ notThere: 'xyz' });
userMapper.select(({ or, cmpr }) =>
// @ts-expect-error - where expression columns must be valid
or([cmpr('notThere', '=', 'Sue')])
);
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('notThere', '=', 'foo');
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('users.notThere', '=', 'foo');
// @ts-expect-error - ID filter must have correct type
userMapper.select('str');
// @ts-expect-error - ID filter must have correct type
userMapper.select(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select([1]);
});
});
|
src/tests/select-general.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " });\n it('selects via key column values', async () => {\n await userMapper.insert().run(USERS);\n // Test selecting via key value\n const users1 = await userMapper.select(2).returnAll();\n expect(users1.length).toEqual(1);\n expect(users1[0].handle).toEqual(USERS[1].handle);\n // Test selecting via key tuple\n const users2 = await userMapper.select([2]).returnAll();\n expect(users2.length).toEqual(1);",
"score": 0.9254642724990845
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users.length).toEqual(1);\n expect(users[0].handle).toEqual(USERS[1].handle);\n });\n it('selects many returning selected columns and aliases', async () => {\n const ids = await userMapper.insert().returnAll(USERS);\n const mapper = new TableMapper(db, 'users', {\n selectedColumns: ['id', 'handle as h'],\n });\n // Should allow access to aliased columns\n (await mapper.select().returnAll())[0].h;",
"score": 0.9089902639389038
},
{
"filename": "src/tests/select-one.test.ts",
"retrieved_chunk": " it('selects one returning selected columns and aliases', async () => {\n const ids = await userMapper.insert().returnAll(USERS);\n const mapper = new TableMapper(db, 'users', {\n selectedColumns: ['id', 'handle as h'],\n });\n // Should allow access to aliased columns\n (await mapper.select().returnOne())!.h;\n const user = await mapper.select({ handle: USERS[0].handle }).returnOne();\n expect(user).toEqual({ id: ids[0].id, h: USERS[0].handle });\n ignore('inaccessible types are not allowed', async () => {",
"score": 0.9020403027534485
},
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " const insertTransformMapper = createInsertTransformMapper(db);\n // @ts-expect-error - requires InsertedObject as input\n await insertTransformMapper.insert().returnOne(USERS[0]);\n // @ts-expect-error - requires InsertedObject as input\n await insertTransformMapper.insert().run(USERS[0]);\n // @ts-expect-error - requires InsertedObject as input\n await insertTransformMapper.insert().returnOne(selectedUser1);\n // @ts-expect-error - requires InsertedObject as input\n await insertTransformMapper.insert().run(selectedUser1);\n });",
"score": 0.8955117464065552
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " const filter1 = { name: 'Not There' as const } as const;\n await userMapper.select(filter1).returnAll();\n await userMapper.select(filter1).returnOne();\n const filter2 = { name: ['name1', 'name2'] as const } as const;\n await userMapper.select(filter2).returnAll();\n await userMapper.select(filter2).returnOne();\n });\n it('selects nothing when nothing matches filter', async () => {\n await userMapper.insert().run(USERS);\n const users = await userMapper.select({ name: 'Not There' }).returnAll();",
"score": 0.8955078721046448
}
] |
typescript
|
await mapper.insert().run(USERS);
|
import { Kysely } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createUserMapperReturningID } from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { TableMapper } from '../mappers/table-mapper';
let db: Kysely<Database>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
beforeAll(async () => {
db = await createDB();
userMapperReturningID = createUserMapperReturningID(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating specific columns', () => {
it('subsets updating columns, excluding ID', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { id: 100, name: 'Sue Rex', email: 'rex@abc.def' };
const subsetQuery = userMapperReturningID
.update('id', '=', insertReturns[0].id)
.columns(['name'] as const); // allows readonly array
const updateReturns = await subsetQuery.returnAll(updateValues);
expect(updateReturns).toEqual([{ id: insertReturns[0].id }]);
const readUsers = await userMapperReturningID
.select('id', '=', insertReturns[0].id)
.returnOne();
expect(readUsers).toEqual({
id: insertReturns[0].id,
name: 'Sue Rex',
email: USERS[0].email,
handle: USERS[0].handle,
});
});
it('subsets updating columns, including ID', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { id: 100, name: 'Sue Rex', email: 'rex@abc.def' };
const subsetQuery = userMapperReturningID
.update('id', '=', insertReturns[0].id)
.columns(['id', 'name', 'email']);
const updateReturns = await subsetQuery.returnAll(updateValues);
expect(updateReturns).toEqual([{ id: 100 }]);
const readUsers = await userMapperReturningID
.select('id', '=', 100)
.returnOne();
expect(readUsers).toEqual({
id: 100,
name: 'Sue Rex',
email: 'rex@abc.def',
handle: USERS[0].handle,
});
});
it('requires all subsetted columns to be updated', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { name: 'Sue Rex' };
const subsetQuery = userMapperReturningID
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email']);
expect(() => subsetQuery.returnAll(updateValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await subsetQuery.run({ ...updateValues, email: null });
expect(success).toBe(true);
});
it('provides updateTransform with column subset', async () => {
expect.assertions(1);
const mapper = new TableMapper(db, 'users').withTransforms({
|
updateTransform: (source, columns) => {
|
expect(columns).toEqual(['name', 'handle']);
return source;
},
});
await mapper.update().columns(['name', 'handle']).run({
name: 'John Doe',
handle: 'johndoe',
email: 'jdoe@abc.def',
});
});
});
|
src/tests/update-columns.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " });\n it('requires all subsetted columns to be inserted', async () => {\n const subsetQuery = userMapperReturningID\n .insert()\n .columns(['name', 'handle', 'email']);\n const insertValues = { name: 'John Doe', handle: 'johndoe' };\n expect(() => subsetQuery.returnOne(insertValues)).rejects.toThrow(\n `column 'email' missing`\n );\n const success = await subsetQuery.run({ ...insertValues, email: null });",
"score": 0.9231408834457397
},
{
"filename": "src/tests/insert-columns.test.ts",
"retrieved_chunk": " expect(success).toBe(true);\n });\n it('provides insertTransform with column subset', async () => {\n expect.assertions(1);\n const mapper = userMapperReturningID.withTransforms({\n insertTransform: (source, columns) => {\n expect(columns).toEqual(['name', 'handle']);\n return source;\n },\n });",
"score": 0.9188743233680725
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " notThere: 32,\n }\n );\n });\n });\n it('compiles an update query with transformation', async () => {\n expect.assertions(12);\n const columnSubset: (keyof Updateable<Users>)[] = ['name'];\n const transformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['*'],",
"score": 0.9055250883102417
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " },\n updateTransform: (source: User, columns) => {\n expect(columns).toEqual(columnSubset);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n updateReturnTransform: (_source, returns) => {",
"score": 0.8966429233551025
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " expect(() => compilation.returnOne({}, updateValues)).rejects.toThrow(\n `column 'email' missing`\n );\n const success = await compilation.run({}, { ...updateValues, email: null });\n expect(success).toBe(true);\n });\n});",
"score": 0.895666778087616
}
] |
typescript
|
updateTransform: (source, columns) => {
|
/**
* Tests TableMapper.selectMany(), TableMapper.selectOne(), and query filters.
*/
import { Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningID(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('general selection', () => {
it('compiles an unparameterized select query', async () => {
await userMapper.insert().run(USERS);
const compilation = userMapper.select({ name: USERS[0].name }).compile();
const users = await compilation.returnAll({});
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
const user = await compilation.returnOne({});
expect(user?.handle).toEqual(USERS[0].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
ignore('compilation type errors', () => {
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
});
});
it('parameterizes and compiles a select query', async () => {
await userMapper.insert().run(USERS);
const parameterization = userMapper.parameterize<{ name: string }>(
(
|
{ mapper, param }) => mapper.select({ name: param('name') })
);
|
// test returnAll() returning multiple
const users = await parameterization.returnAll({ name: USERS[0].name });
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[0].handle);
expect(users[1].handle).toEqual(USERS[2].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(users[0].handle);
// test returnAll() returning none
const users2 = await parameterization.returnAll({ name: 'not there' });
expect(users2.length).toEqual(0);
// test returnOne() returning one
const user = await parameterization.returnOne({ name: USERS[1].name });
expect(user?.handle).toEqual(USERS[1].handle);
// Ensure that the provided columns are not optional
((_: string) => {})(user!.name);
// test returnOne() returning none
const user2 = await parameterization.returnOne({ name: 'not there' });
expect(user2).toBeNull();
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ notThere: 'foo' });
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user!.notThere;
userMapper.parameterize<{ name: string }>(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') })
);
userMapper.parameterize<{ name: number }>(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') })
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ name: 123 });
});
});
it('modifies the underlying query builder', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(USERS[2].handle);
expect(users[1].handle).toEqual(USERS[0].handle);
const user = await userMapper
.select()
.modify((qb) =>
qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')
)
.returnOne();
expect(user?.handle).toEqual(USERS[2].handle);
});
it('does not modify the underlying selected columns', async () => {
await userMapper.insert().run(USERS);
const users = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnAll();
expect(users).toEqual([
{ ...USERS[2], id: 3 },
{ ...USERS[1], id: 2 },
{ ...USERS[0], id: 1 },
]);
// Ensure that columns can be addressed by name.
((_: number) => {})(users[0].id);
((_: string) => {})(users[0].handle);
((_: string) => {})(users[0].name);
((_: string) => {})(users[0].email!);
const user = await userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnOne();
expect(user).toEqual({ ...USERS[2], id: 3 });
// Ensure that columns can be addressed by name.
((_: number) => {})(user!.id);
((_: string) => {})(user!.handle);
((_: string) => {})(user!.name);
((_: string) => {})(user!.email!);
ignore('detects modify() type errors', async () => {
// @ts-expect-error - cannot access invalid columns
users[0].notThere;
// @ts-expect-error - cannot access invalid columns
user!.notThere;
});
});
it('selects via a multi-column key tuple (definition order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id', 'name'],
});
await mapper.insert().run(USERS);
const users = await mapper.select([3, 'Sue']).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
it('selects via a multi-column key tuple (different order)', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['name', 'id'],
});
await mapper.insert().run(USERS);
const users = await mapper.select(['Sue', 3]).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(USERS[2].name);
ignore('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
});
ignore('detects select(filter) type errors', async () => {
// @ts-expect-error - doesn't allow only two arguments
userMapper.select('name', '=');
// @ts-expect-error - object filter fields must be valid
userMapper.select({ notThere: 'xyz' });
userMapper.select(({ or, cmpr }) =>
// @ts-expect-error - where expression columns must be valid
or([cmpr('notThere', '=', 'Sue')])
);
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('notThere', '=', 'foo');
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('users.notThere', '=', 'foo');
// @ts-expect-error - ID filter must have correct type
userMapper.select('str');
// @ts-expect-error - ID filter must have correct type
userMapper.select(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select([1]);
});
});
|
src/tests/select-general.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " });\n it('parameterizes and compiles a delete query', async () => {\n const parameterization = userMapper.parameterize<{ targetName: string }>(\n ({ mapper, param }) => mapper.delete({ name: param('targetName') })\n );\n const count1 = await parameterization.returnCount({\n targetName: USERS[0].name,\n });\n expect(count1).toEqual(0);\n await userMapper.insert().run(USERS);",
"score": 0.9245742559432983
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " expect(count3).toEqual(1);\n const users2 = await userMapper.select().returnAll();\n expect(users2.length).toEqual(0);\n ignore('parameterization type errors', () => {\n // @ts-expect-error - errors on invalid parameter names\n parameterization.run({ notThere: 'foo' });\n userMapper.parameterize<{ name: string }>(\n // @ts-expect-error - errors on invalid parameter name\n ({ mapper, param }) => mapper.select({ name: param('notThere') })\n );",
"score": 0.9163309335708618
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": " userMapper.parameterize<{ name: number }>(\n // @ts-expect-error - errors on invalid parameter type\n ({ mapper, param }) => mapper.select({ name: param('name') })\n );\n // @ts-expect-error - errors on invalid parameter value name\n parameterization.run({ notThere: 'foo' });\n // @ts-expect-error - errors on invalid parameter value type\n parameterization.run({ targetName: 123 });\n });\n });",
"score": 0.9113606810569763
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(insertReturn!.name);\n // test run()\n const success1 = await compilation.run(USERS[1]);\n expect(success1).toBe(true);\n // test that non-specified columns are not inserted\n const success2 = await compilation.run({ ...USERS[2], id: 100 });\n expect(success2).toBe(true);\n const readUsers = await userMapperReturningAll.select().returnAll();\n expect(readUsers.length).toEqual(3);",
"score": 0.9039790630340576
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " const filter1 = { name: 'Not There' as const } as const;\n await userMapper.select(filter1).returnAll();\n await userMapper.select(filter1).returnOne();\n const filter2 = { name: ['name1', 'name2'] as const } as const;\n await userMapper.select(filter2).returnAll();\n await userMapper.select(filter2).returnOne();\n });\n it('selects nothing when nothing matches filter', async () => {\n await userMapper.insert().run(USERS);\n const users = await userMapper.select({ name: 'Not There' }).returnAll();",
"score": 0.9006600379943848
}
] |
typescript
|
{ mapper, param }) => mapper.select({ name: param('name') })
);
|
/**
* Tests TableMapper.selectMany(), TableMapper.selectOne(), and query filters.
*/
import { Kysely, sql } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { createUserMapperReturningID } from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapper: ReturnType<typeof createUserMapperReturningID>;
beforeAll(async () => {
db = await createDB();
userMapper = createUserMapperReturningID(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('selecting one return', () => {
it('selects the first row with no filter', async () => {
await userMapper.insert().run(USERS);
let user = await userMapper.select().returnOne();
expect(user?.handle).toEqual(USERS[0].handle);
user = await userMapper.select({}).returnOne();
expect(user?.handle).toEqual(USERS[0].handle);
});
it('selects the first row with a matching field filter', async () => {
await userMapper.insert().run(USERS);
let user = await userMapper.select({ name: USERS[0].name }).returnOne();
expect(user?.handle).toEqual(USERS[0].handle);
user = await userMapper
.select({
name: USERS[0].name,
handle: USERS[2].handle,
})
.returnOne();
expect(user?.handle).toEqual(USERS[2].handle);
user = await userMapper
.select({
id: [1, 2],
handle: [USERS[1].handle, USERS[2].handle],
})
.returnOne();
expect(user?.handle).toEqual(USERS[1].handle);
});
it('selects the first row with a binary operation filter', async () => {
await userMapper.insert().run(USERS);
// Test selecting by condition (with result)
let user = await userMapper.select('name', '=', USERS[0].name).returnOne();
expect(user?.handle).toEqual(USERS[0].handle);
// Test selecting by condition (no result)
user = await userMapper.select('name', '=', 'nonexistent').returnOne();
expect(user).toBeNull();
});
it('selects the first row with a query expression filter', async () => {
await userMapper.insert().run(USERS);
const user = await userMapper
.select(sql`name != ${USERS[0].name}`)
.returnOne();
expect(user?.handle).toEqual(USERS[1].handle);
});
it('selects the first row with a compound filter', async () => {
const userIDs = await userMapper.insert().returnAll(USERS);
const user = await userMapper
.select(({ and, cmpr }) =>
and([cmpr('name', '=', USERS[0].name), cmpr('id', '>', userIDs[0].id)])
)
.returnOne();
expect(user?.handle).toEqual(USERS[2].handle);
});
it('selects one returning selected columns and aliases', async () => {
const ids = await userMapper.insert().returnAll(USERS);
const mapper = new TableMapper(db, 'users', {
selectedColumns: ['id', 'handle as h'],
});
// Should allow access to aliased columns
|
(await mapper.select().returnOne())!.h;
|
const user = await mapper.select({ handle: USERS[0].handle }).returnOne();
expect(user).toEqual({ id: ids[0].id, h: USERS[0].handle });
ignore('inaccessible types are not allowed', async () => {
// @ts-expect-error - unselected columns are not allowed
(await mapper.select().returnAll())[0].name;
});
});
ignore('detects selecting returnOne() type errors', async () => {
// @ts-expect-error - only table columns are accessible unfiltered
(await userMapper.select({}).returnOne()).notThere;
// @ts-expect-error - only table columns are accessible w/ object filter
(await userMapper.select({ name: 'Sue' }).returnOne()).notThere;
// @ts-expect-error - only table columns are accessible w/ op filter
// prettier-ignore
(await userMapper.select("name", "=", "Sue").returnOne()).notThere;
// prettier-ignore
(
await userMapper
.select((qb) => qb)
.returnOne()
// @ts-expect-error - only table columns are accessible w/ QB filter
)!.notThere;
// prettier-ignore
(
await userMapper
.select(sql`name = 'Sue'`)
.returnOne()
// @ts-expect-error - only table columns are accessible w/ expr filter
)!.notThere;
});
});
|
src/tests/select-one.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " expect(users.length).toEqual(1);\n expect(users[0].handle).toEqual(USERS[1].handle);\n });\n it('selects many returning selected columns and aliases', async () => {\n const ids = await userMapper.insert().returnAll(USERS);\n const mapper = new TableMapper(db, 'users', {\n selectedColumns: ['id', 'handle as h'],\n });\n // Should allow access to aliased columns\n (await mapper.select().returnAll())[0].h;",
"score": 0.9778598546981812
},
{
"filename": "src/tests/select-all.test.ts",
"retrieved_chunk": " });\n it('selects via key column values', async () => {\n await userMapper.insert().run(USERS);\n // Test selecting via key value\n const users1 = await userMapper.select(2).returnAll();\n expect(users1.length).toEqual(1);\n expect(users1[0].handle).toEqual(USERS[1].handle);\n // Test selecting via key tuple\n const users2 = await userMapper.select([2]).returnAll();\n expect(users2.length).toEqual(1);",
"score": 0.940473198890686
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " expect(users[1].handle).toEqual(USERS[0].handle);\n const user = await userMapper\n .select()\n .modify((qb) =>\n qb.where('name', '=', USERS[0].name).orderBy('handle', 'desc')\n )\n .returnOne();\n expect(user?.handle).toEqual(USERS[2].handle);\n });\n it('does not modify the underlying selected columns', async () => {",
"score": 0.9291239380836487
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " mapper.select(1);\n });\n });\n it('selects via a multi-column key tuple (different order)', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['name', 'id'],\n });\n await mapper.insert().run(USERS);\n const users = await mapper.select(['Sue', 3]).returnAll();\n expect(users.length).toEqual(1);",
"score": 0.9290841221809387
},
{
"filename": "src/tests/select-general.test.ts",
"retrieved_chunk": " });\n });\n it('selects via a multi-column key tuple (definition order)', async () => {\n const mapper = new TableMapper(db, 'users', {\n keyColumns: ['id', 'name'],\n });\n await mapper.insert().run(USERS);\n const users = await mapper.select([3, 'Sue']).returnAll();\n expect(users.length).toEqual(1);\n expect(users[0].name).toEqual(USERS[2].name);",
"score": 0.9256097078323364
}
] |
typescript
|
(await mapper.select().returnOne())!.h;
|
import { Insertable, Kysely, Selectable, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import { ignore } from './utils/test-utils';
import { SelectionColumn } from '../lib/type-utils';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('table mapper setting type checks', () => {
ignore('detects invalid return columns configurations', () => {
new TableMapper<Database, 'users', ['id']>(db, 'users', {
// @ts-expect-error - invalid return column configuration
insertReturnColumns: ['notThere'],
// @ts-expect-error - invalid return column configuration
updateReturnColumns: ['notThere'],
});
new TableMapper<Database, 'users', ['id']>(db, 'users', {
// @ts-expect-error - actual and declared return types must match
insertReturnColumns: ['id', 'name'],
// @ts-expect-error - actual and declared return types must match
updateReturnColumns: ['id', 'name'],
});
new TableMapper<
Database,
'users',
[],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
bigint,
// @ts-expect-error - invalid return column configuration
['notThere']
>(db, 'users', {});
new TableMapper<
Database,
'users',
[],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
bigint,
['name'],
// @ts-expect-error - invalid return column configuration
['name', 'notThere']
>(db, 'users', {});
new TableMapper<Database, 'users', ['id']>(db, 'users', {
// @ts-expect-error - invalid return column configuration
insertReturnColumns: [''],
// @ts-expect-error - invalid return column configuration
updateReturnColumns: [''],
});
new TableMapper<Database, 'users', ['id']>(db, 'users', {
// @ts-expect-error - invalid return column configuration
insertReturnColumns: ['notThere'],
// @ts-expect-error - invalid return column configuration
updateReturnColumns: ['notThere'],
});
class TestMapper6<
InsertReturnColumns extends
| SelectionColumn<Database, 'users'>[]
| ['*'] = [],
UpdateReturnColumns extends
| SelectionColumn<Database, 'users'>[]
| ['*'] = []
> extends TableMapper<
Database,
'users',
[],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
number,
InsertReturnColumns,
UpdateReturnColumns
> {}
new TestMapper6(db, 'users', {
// @ts-expect-error - invalid return column configuration
insertReturnColumns: ['notThere'],
// @ts-expect-error - invalid return column configuration
updateReturnColumns: ['notThere'],
});
new TableMapper<
Database,
'users',
[],
any,
any,
any,
any,
number,
['id', 'name']
>(db, 'users', {
// @ts-expect-error - actual and declared return types must match
insertReturnColumns: ['id'],
// @ts-expect-error - actual and declared return types must match
updateReturnColumns: ['id'],
});
new TableMapper<
Database,
'users',
[],
any,
any,
any,
any,
number,
['*'],
['*']
>(db, 'users', {
// @ts-expect-error - actual and declared return types must match
insertReturnColumns: ['id'],
// @ts-expect-error - actual and declared return types must match
updateReturnColumns: ['id'],
});
new TableMapper<Database, 'users', [], any, any, any, any, number, [], []>(
db,
'users',
{
// @ts-expect-error - actual and declared return types must match
insertReturnColumns: ['id'],
// @ts-expect-error - actual and declared return types must match
updateReturnColumns: ['id'],
}
);
});
ignore('detects invalid return count configuration', () => {
class TestMapper extends TableMapper<
Database,
'users',
['id'],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
number
> {}
new TestMapper(db, 'users', {
// @ts-expect-error - invalid return count
countTransform: (count: bigint) => BigInt(count),
});
});
it('accepts readonly KeyColumns', () => {
new TableMapper<
Database,
'users',
Readonly<['id']> // should not error
>(db, 'users', {});
});
it('accepts readonly SelectedColumns', () => {
new TableMapper<
Database,
'users',
['id'],
Readonly<['id', 'name']> // should not error
>(db, 'users', {});
});
it('accepts readonly return columns', () => {
new TableMapper<
Database,
'users',
['id'],
['*'],
Selectable<Users>,
Insertable<Users>,
Updateable<Users>,
bigint,
Readonly<['id']>, // should not error
Readonly<['name']> // should not error
>(db, 'users', {});
});
it('accepts readonly settings', () => {
const settings = {
insertReturnColumns: ['id'] as const,
updateReturnColumns: ['name'] as const,
} as const;
|
new TableMapper(db, 'users', settings);
|
});
});
|
src/tests/setting-types.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " it('accepts readonly transforms', () => {\n const transforms = {\n countTransform: (count: bigint) => count,\n } as const;\n new TableMapper(db, 'users', {}).withTransforms(transforms);\n });\n});",
"score": 0.9078001976013184
},
{
"filename": "src/mappers/abstract-table-mapper.ts",
"retrieved_chunk": " readonly settings: Readonly<\n TableMapperSettings<\n DB,\n TB,\n KeyColumns,\n SelectedColumns,\n InsertReturnColumns,\n UpdateReturnColumns\n >\n > = {}",
"score": 0.8901224732398987
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " ) {}\n }\n const keyColumns = ['id'] as const;\n const userMapper = new TableMapper(db, 'users', {\n keyColumns,\n updateReturnColumns: ['id', 'name'],\n }).withTransforms(new EntireRowTransforms(keyColumns));\n // test updating a non-existent user\n const userWithID = new MappedUser(\n 1,",
"score": 0.8728101253509521
},
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " ignore('detects invalid insert transform configuration', () => {\n new TableMapper(db, 'users').withTransforms({\n // @ts-expect-error - invalid insert transform\n insertTransform: (user: User) => user,\n });\n });\n ignore('detects invalid update transform configuration', () => {\n new TableMapper(db, 'users').withTransforms({\n // @ts-expect-error - invalid update transform\n updateTransform: (_user) => ({ noId: 1 }),",
"score": 0.8689981698989868
},
{
"filename": "src/tests/delete.test.ts",
"retrieved_chunk": "});\nbeforeEach(() => resetDB(db));\nafterAll(() => destroyDB(db));\ndescribe('deleting rows via TableMapper', () => {\n it('accepts readonly filters', async () => {\n const filter = { name: 'Not There' as const } as const;\n await userMapper.delete(filter).run();\n await userMapper.delete(filter).returnCount();\n });\n it(\"doesn't delete anything if no rows match\", async () => {",
"score": 0.8665555119514465
}
] |
typescript
|
new TableMapper(db, 'users', settings);
|
import { Kysely } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import { User } from './utils/test-types';
import { ignore } from './utils/test-utils';
import { createInsertTransformMapper } from './utils/test-mappers';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('table mapper transform type checks', () => {
ignore('detects invalid select transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid select transform
selectTransform: (user: User) => user,
});
});
ignore('detects invalid insert transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid insert transform
insertTransform: (user: User) => user,
});
});
ignore('detects invalid update transform configuration', () => {
new TableMapper(db, 'users').withTransforms({
// @ts-expect-error - invalid update transform
updateTransform: (_user) => ({ noId: 1 }),
});
});
ignore('detects invalid update return transform return', async () => {
const mapper = new TableMapper(db, 'users', { keyColumns: ['id'] });
mapper.withTransforms({
selectTransform: (_user) => new User(1, 'John', 'Doe', 'jdoe', 'x@y.z'),
updateTransform: (user: User) => ({
id: user.id,
name: `${user.firstName} ${user.lastName}`,
handle: user.handle,
email:
|
user.email,
}),
updateReturnTransform: (_user, returns) => returns,
});
|
(await mapper
.update({ id: 1 })
// @ts-expect-error - ensure that return type is User
.returnOne(new User(1, 'John', 'Doe', 'jdoe', 'jdoe@abc.def')))!.name;
});
ignore('detects insertion transformation type errors', async () => {
const insertTransformMapper = createInsertTransformMapper(db);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().returnOne(USERS[0]);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().run(USERS[0]);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().returnOne(selectedUser1);
// @ts-expect-error - requires InsertedObject as input
await insertTransformMapper.insert().run(selectedUser1);
});
it('accepts readonly transforms', () => {
const transforms = {
countTransform: (count: bigint) => count,
} as const;
new TableMapper(db, 'users', {}).withTransforms(transforms);
});
});
|
src/tests/transform-types.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " updateReturnColumns: ['*'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,",
"score": 0.9205087423324585
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (user: MappedUser) => ({\n name: `${user.firstName} ${user.lastName}`,\n handle: user.handle,\n email: user.email,\n }),\n insertReturnTransform: (user, returns) =>\n new MappedUser(\n returns.id,",
"score": 0.9157071709632874
},
{
"filename": "src/tests/utils/test-mappers.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n countTransform: (count) => Number(count),\n });\n}",
"score": 0.9142845869064331
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " name: `${user.firstName} ${user.lastName}`,\n handle: user.handle + '2',\n email: user.email,\n };\n },\n updateReturnTransform: (user, returns) => {\n return new MappedUser(\n returns.id,\n user.firstName,\n user.lastName,",
"score": 0.8995190858840942
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " updateTransform: (source: UpdatingUser, columns) => {\n expect(columns).toEqual(['*']);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n updateReturnTransform: (source: UpdatingUser, returns) =>\n new ReturnedUser(",
"score": 0.8957967758178711
}
] |
typescript
|
user.email,
}),
updateReturnTransform: (_user, returns) => returns,
});
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
createUserMapperReturningID,
createUserMapperReturningIDAndHandleAsH,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { User } from './utils/test-types';
let db: Kysely<Database>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningIDAndHandleAsH: ReturnType<
typeof createUserMapperReturningIDAndHandleAsH
>;
beforeAll(async () => {
db = await createDB();
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningIDAndHandleAsH =
createUserMapperReturningIDAndHandleAsH(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('compiled updates', () => {
it('updates nothing returning zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const compilation = userMapperReturningID
.update({ id: 1 })
.columns(['email'])
.compile();
const success2 = await compilation.run({}, updateValues);
expect(success2).toBe(false);
const updateCount2 = await compilation.returnCount({}, updateValues);
expect(updateCount2).toEqual(0);
const updates2 = await compilation.returnAll({}, updateValues);
expect(updates2.length).toEqual(0);
const update2 = await compilation.returnOne({}, updateValues);
expect(update2).toBeNull();
});
it('compilations accept readonly updating objects', async () => {
const compilation = userMapperReturningNothing
.update('id', '=', 1)
.columns(['name', 'email'])
.compile();
const updateValues1 = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
await compilation.run({}, updateValues1);
});
it('compiles a non-returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningNothing
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = {
name: 'Johnny Rex' as const,
email: 'jrex@abc.def' as const,
} as const;
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2).toBeUndefined();
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3).toBeUndefined();
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
});
it('compiles a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const compilation = userMapperReturningIDAndHandleAsH
.update('id', '=', insertReturns[0].id)
.columns(['name', 'email'])
.compile();
// test run()
const updateValues1 = { name: 'Sue Rex', email: 'srex@abc.def' };
const updateReturns1 = await compilation.run({}, updateValues1);
expect(updateReturns1).toBe(true);
const readUser1 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser1?.name).toEqual(updateValues1.name);
expect(readUser1?.email).toEqual(updateValues1.email);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex', email: 'jrex@abc.def' };
const updateReturns2 = await compilation.returnOne({}, updateValues2);
expect(updateReturns2?.id).toEqual(insertReturns[0].id);
expect(updateReturns2?.h).toEqual(USERS[0].handle);
const readUser2 = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser2?.name).toEqual(updateValues2.name);
expect(readUser2?.email).toEqual(updateValues2.email);
// test returnAll()
const updateReturns3 = await compilation.returnAll({}, updateValues1);
expect(updateReturns3[0].id).toEqual(insertReturns[0].id);
expect(updateReturns3[0].h).toEqual(USERS[0].handle);
// test returnCount()
const updateReturns4 = await compilation.returnCount({}, updateValues2);
expect(updateReturns4).toEqual(1);
ignore('check compile-time types', () => {
compilation.returnOne(
{},
{
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
// @ts-expect-error - only insertable columns are allowed
notThere: 32,
}
);
// @ts-expect-error - only expected columns are returned
updateReturns2!.handle;
// @ts-expect-error - only expected columns are returned
updateReturns3[0].handle;
});
});
it('accepts readonly parameters and updating objects', async () => {
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
const params = { id: 1 as const } as const;
const updateValues = {
name: 'Sue Rex' as const,
email: 'srex@abc.def' as const,
} as const;
await parameterization.run(params, updateValues);
await parameterization.returnAll(params, updateValues);
await parameterization.returnOne(params, updateValues);
await parameterization.returnCount(params, updateValues);
});
it('parameterizes a returning update query without transformation', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const parameterization = userMapperReturningIDAndHandleAsH.parameterize<{
id: number;
}>(({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test run()
const updateValues1 = { name: 'Sue Rex' };
const updateReturns1 = await parameterization.run(
{ id: insertReturns[0].id },
updateValues1
);
expect(updateReturns1).toBe(true);
// test returnOne()
const updateValues2 = { name: 'Johnny Rex' };
const updateReturns2 = await parameterization.returnOne(
{ id: insertReturns[1].id },
updateValues2
);
expect(updateReturns2?.id).toEqual(insertReturns[1].id);
expect(updateReturns2?.h).toEqual(USERS[1].handle);
// test returnAll()
const updateReturns3 = await parameterization.returnAll(
{ id: insertReturns[2].id },
updateValues1
);
expect(updateReturns3[0].id).toEqual(insertReturns[2].id);
expect(updateReturns3[0].h).toEqual(USERS[2].handle);
// verify updates
const readUsers = await userMapperReturningID.select().returnAll();
expect(readUsers[0].name).toEqual(updateValues1.name);
expect(readUsers[1].name).toEqual(updateValues2.name);
expect(readUsers[2].name).toEqual(updateValues1.name);
// test returnCount()
const updateReturns4 = await parameterization.returnCount(
{ id: insertReturns[0].id },
updateValues2
);
expect(updateReturns4).toEqual(1);
const readUser = await userMapperReturningID
.select({ id: insertReturns[0].id })
.returnOne();
expect(readUser?.name).toEqual(updateValues2.name);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid column names
updateReturns2!.handle;
// @ts-expect-error - errors on invalid column names
updateReturns3[0].handle;
userMapperReturningIDAndHandleAsH.parameterize<{ id: number }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
userMapperReturningIDAndHandleAsH.parameterize<{ id: string }>(
({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, updateValues1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, updateValues1);
parameterization.returnOne(
{ id: 1 },
{
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
// @ts-expect-error - only updateable columns are allowed
notThere: 32,
}
);
});
});
it('compiles an update query with transformation', async () => {
expect.assertions(12);
const columnSubset: (keyof Updateable<Users>)[] = ['name'];
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['*'],
updateReturnColumns: ['*'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
insertReturnTransform: (
|
_source, returns) => {
|
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
updateTransform: (source: User, columns) => {
expect(columns).toEqual(columnSubset);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (_source, returns) => {
const names = returns.name.split(' ');
return new User(
returns.id,
names[0],
names[1],
returns.handle,
returns.email
);
},
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');
const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const compilation = transformMapper
.update({ id: insertReturns[2].id })
.columns(columnSubset)
.compile();
// test returnOne()
const updateReturn1 = await compilation.returnOne({}, user1);
const expectedUser1 = User.create(insertReturns[2].id, {
firstName: user1.firstName,
lastName: user1.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn1).toEqual(expectedUser1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
const readUser1 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser1).toEqual(expectedUser1);
// test returnAll()
const updateReturn2 = await compilation.returnAll({}, user2);
const expectedUser2 = User.create(insertReturns[2].id, {
firstName: user2.firstName,
lastName: user2.lastName,
handle: user3.handle,
email: user3.email,
});
expect(updateReturn2[0]).toEqual(expectedUser2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
const readUser2 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser2).toEqual(expectedUser2);
// test run()
const success1 = await compilation.run({}, user1);
expect(success1).toBe(true);
const readUser3 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser3).toEqual(expectedUser1);
// test returnCount()
const count = await compilation.returnCount({}, user2);
expect(count).toEqual(1);
const readUser4 = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser4).toEqual(expectedUser2);
ignore('check compile-time types', async () => {
// @ts-expect-error - only update objects are allowed
compilation.returnOne({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnAll({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.returnCount({}, USERS[0]);
// @ts-expect-error - only update objects are allowed
compilation.run({}, USERS[0]);
// @ts-expect-error - correct return is expected
(await compilation.returnOne({}, user1))!.name;
// @ts-expect-error - correct return is expected
(await compilation.returnAll({}, user2))[0].name;
});
});
it('parameterizes an update query with transformation', async () => {
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
insertReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
updateTransform: (source: User) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
updateReturnTransform: (source: User, returns) => ({
id: returns.id,
firstName: source.firstName,
lastName: source.lastName,
}),
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');
const user3 = new User(0, 'Sue', 'Rex', 'srex', 'srex@abc.def');
const insertReturns = await transformMapper
.insert()
.returnAll([user1, user2, user3]);
const parameterization = transformMapper.parameterize<{ id: number }>(
({ mapper, param }) =>
mapper.update({ id: param('id') }).columns(['name'])
);
// test returnOne()
const updateReturn1 = await parameterization.returnOne(
{ id: insertReturns[0].id },
user2
);
const expectedReturn1 = {
id: insertReturns[0].id,
firstName: user2.firstName,
lastName: user2.lastName,
};
expect(updateReturn1).toEqual(expectedReturn1);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn1!.firstName);
// test returnAll()
const updateReturn2 = await parameterization.returnAll(
{ id: insertReturns[1].id },
user3
);
const expectedReturn2 = {
id: insertReturns[1].id,
firstName: user3.firstName,
lastName: user3.lastName,
};
expect(updateReturn2[0]).toEqual(expectedReturn2);
// Ensure that the provided columns are accessible
((_: string) => {})(updateReturn2[0]!.firstName);
// test run()
const success1 = await parameterization.run(
{ id: insertReturns[2].id },
user1
);
const expectedReturn3 = {
id: insertReturns[2].id,
firstName: user1.firstName,
lastName: user1.lastName,
};
expect(success1).toBe(true);
// verify updates
const readUsers = await transformMapper.select().returnAll();
expect(readUsers).toEqual([
User.create(expectedReturn1.id, {
...expectedReturn1,
handle: user1.handle,
email: user1.email!,
}),
User.create(expectedReturn2.id, {
...expectedReturn2,
handle: user2.handle,
email: user2.email!,
}),
User.create(expectedReturn3.id, {
...expectedReturn3,
handle: user3.handle,
email: user3.email!,
}),
]);
// test returnCount()
const count = await parameterization.returnCount(
{ id: insertReturns[2].id },
user2
);
expect(count).toEqual(1);
const readUser = await transformMapper
.select({ id: insertReturns[2].id })
.returnOne();
expect(readUser).toEqual(
User.create(insertReturns[2].id, {
...expectedReturn1,
handle: user3.handle,
email: user3.email!,
})
);
ignore('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid column names
updateReturn1!.handle;
// @ts-expect-error - errors on invalid column names
updateReturn2[0].handle;
transformMapper.parameterize<{ id: number }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter name
mapper.update({ id: param('handle') }).columns(['name'])
);
transformMapper.parameterize<{ id: string }>(({ mapper, param }) =>
// @ts-expect-error - errors on invalid parameter type
mapper.update({ id: param('id') }).columns(['name'])
);
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ handle: 'foo' }, user1);
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ id: 'foo' }, user1);
parameterization.returnOne(
{ id: 1 },
{
// @ts-expect-error - only updateable columns are allowed
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
}
);
});
});
it('requires all indicated columns to be updated', async () => {
await userMapperReturningID.insert().run(USERS);
const compilation = userMapperReturningID
.update()
.columns(['name', 'handle', 'email'])
.compile();
const updateValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => compilation.returnOne({}, updateValues)).rejects.toThrow(
`column 'email' missing`
);
const success = await compilation.run({}, { ...updateValues, email: null });
expect(success).toBe(true);
});
});
|
src/tests/update-compile.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " handle: source.handle,\n email: source.email,\n };\n }\n return source;\n },\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return SelectedUser.create(row.id, {\n firstName: names[0],",
"score": 0.92296302318573
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(columns).toEqual(['*']);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n insertReturnTransform: (source: InsertedUser, returns) =>\n new ReturnedUser(\n returns.id,",
"score": 0.9189236164093018
},
{
"filename": "src/tests/insert-compile.test.ts",
"retrieved_chunk": " insertTransform: (source: User, columns) => {\n expect(columns).toEqual(columnSubset);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n insertReturnTransform: (source: User, returns) =>\n new User(",
"score": 0.9110717177391052
},
{
"filename": "src/tests/utils/test-mappers.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n countTransform: (count) => Number(count),\n });\n}",
"score": 0.90179443359375
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " user.handle,\n user.email\n );\n },\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new MappedUser(\n row.id,\n names[0],\n names[1],",
"score": 0.8990291357040405
}
] |
typescript
|
_source, returns) => {
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
userObject1,
userRow1,
userRow2,
userRow3,
} from './utils/test-objects';
import { ReturnedUser, UpdatingUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating with transformation', () => {
it('transforms users for update without transforming return', async () => {
const mapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
});
const insertReturns = await mapper
.insert()
.returnAll([userRow1, userRow2, userRow3]);
const updatingUser1 = UpdatingUser.create(
0,
Object.assign({}, userObject1, { firstName: 'Suzanne' })
);
const updateReturns = await mapper
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updatingUser1);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
const readUsers = await mapper
.select()
.modify((qb) => qb.orderBy('id'))
.returnAll();
expect(readUsers).toEqual([
Object.assign({}, userRow1, {
id: insertReturns[0].id,
name: 'Suzanne Smith',
}),
Object.assign({}, userRow2, { id: insertReturns[1].id }),
Object.assign({}, userRow1, {
id: insertReturns[2].id,
name: 'Suzanne Smith',
}),
]);
});
it('transforms update return into object without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateReturnTransform: (source, returns) =>
new ReturnedUser(
returns.id,
source.name ? source.name.split(' ')[0] : '(first)',
source.name ? source.name.split(' ')[1] : '(last)',
source.handle ? source.handle : '(handle)',
source.email ? source.email : '(email)'
),
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smith',
'(handle)',
'(email)'
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn1[0].firstName);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smithy',
'(handle)',
'(email)'
)
);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn2!.firstName);
});
it('transforms update return into primitive without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
|
insertReturnTransform: (_source, returns) => returns.id,
updateReturnTransform: (_source, returns) => returns.id,
});
|
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([1]);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn1[0]);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(1);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn2!);
});
it("transforms update and update return, columns is ['*']", async () => {
expect.assertions(2);
const updateAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (source: UpdatingUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
});
const insertReturn = await updateAndReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn = await updateAndReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll(UpdatingUser.create(0, userObject1));
expect(updateReturn).toEqual([
new ReturnedUser(
insertReturn.id,
userObject1.firstName,
userObject1.lastName,
userObject1.handle,
userObject1.email
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn[0].firstName);
});
it('transforms a union of updating object types', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser | Updateable<Users>) =>
source instanceof UpdatingUser
? {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}
: source,
});
const insertReturn = await mapper.insert().returnOne(userRow1);
// test with UpdatingUser
await mapper
.update({ id: insertReturn.id })
.columns(['name'])
.run(UpdatingUser.create(0, userObject1));
const readUser1 = await mapper.select(insertReturn.id).returnOne();
expect(readUser1).toEqual({
id: insertReturn.id,
name: `${userObject1.firstName} ${userObject1.lastName}`,
email: userRow1.email,
handle: userRow1.handle,
});
// test with Updateable<Users>
const newName = 'Suzanne Smith Something';
await mapper.update({ id: insertReturn.id }).run({ name: newName });
const readUser2 = await mapper.select(insertReturn.id).returnOne();
expect(readUser2).toEqual({
id: insertReturn.id,
name: newName,
email: userRow1.email,
handle: userRow1.handle,
});
});
});
|
src/tests/update-transform.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });\n // ensure return type can be accessed as a row\n ((_: string) => {})(updatedUser!.name);\n });\n it('transforms insertion return into primitive without transforming insertion', async () => {\n const insertReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n insertReturnTransform: (_source, returns) => returns.id,\n countTransform: (count) => Number(count),",
"score": 0.930854082107544
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " });\n it('transforms insertion return into object without transforming insertion', async () => {\n const insertReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id', 'name'],\n updateReturnColumns: ['id', 'name'],\n }).withTransforms({\n insertReturnTransform: (source, returns) => {\n const names = returns.name.split(' ');\n return new ReturnedUser(\n returns.id,",
"score": 0.9271397590637207
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " // test that updates return rows\n const updateReturn = await transformMapper\n .update({ id: 1 })\n .returnOne(expectedUser2);\n expect(updateReturn).toEqual({\n id: 1,\n name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,\n });\n // ensure return type can be accessed as a row\n ((_: string) => {})(updateReturn!.name);",
"score": 0.917894721031189
},
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " });\n });\n ignore('detects invalid update return transform return', async () => {\n const mapper = new TableMapper(db, 'users', { keyColumns: ['id'] });\n mapper.withTransforms({\n selectTransform: (_user) => new User(1, 'John', 'Doe', 'jdoe', 'x@y.z'),\n updateTransform: (user: User) => ({\n id: user.id,\n name: `${user.firstName} ${user.lastName}`,\n handle: user.handle,",
"score": 0.9147176742553711
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(updateReturn1!.firstName);\n const readUser1 = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser1).toEqual(expectedUser1);\n // test returnAll()\n const updateReturn2 = await compilation.returnAll({}, user2);\n const expectedUser2 = User.create(insertReturns[2].id, {\n firstName: user2.firstName,",
"score": 0.9128531217575073
}
] |
typescript
|
insertReturnTransform: (_source, returns) => returns.id,
updateReturnTransform: (_source, returns) => returns.id,
});
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
userObject1,
userRow1,
userRow2,
userRow3,
} from './utils/test-objects';
import { ReturnedUser, UpdatingUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating with transformation', () => {
it('transforms users for update without transforming return', async () => {
const mapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
});
const insertReturns = await mapper
.insert()
.returnAll([userRow1, userRow2, userRow3]);
const updatingUser1 = UpdatingUser.create(
0,
Object.assign({}, userObject1, { firstName: 'Suzanne' })
);
const updateReturns = await mapper
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updatingUser1);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
const readUsers = await mapper
.select()
.modify(
|
(qb) => qb.orderBy('id'))
.returnAll();
|
expect(readUsers).toEqual([
Object.assign({}, userRow1, {
id: insertReturns[0].id,
name: 'Suzanne Smith',
}),
Object.assign({}, userRow2, { id: insertReturns[1].id }),
Object.assign({}, userRow1, {
id: insertReturns[2].id,
name: 'Suzanne Smith',
}),
]);
});
it('transforms update return into object without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateReturnTransform: (source, returns) =>
new ReturnedUser(
returns.id,
source.name ? source.name.split(' ')[0] : '(first)',
source.name ? source.name.split(' ')[1] : '(last)',
source.handle ? source.handle : '(handle)',
source.email ? source.email : '(email)'
),
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smith',
'(handle)',
'(email)'
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn1[0].firstName);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smithy',
'(handle)',
'(email)'
)
);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn2!.firstName);
});
it('transforms update return into primitive without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
updateReturnTransform: (_source, returns) => returns.id,
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([1]);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn1[0]);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(1);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn2!);
});
it("transforms update and update return, columns is ['*']", async () => {
expect.assertions(2);
const updateAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (source: UpdatingUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
});
const insertReturn = await updateAndReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn = await updateAndReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll(UpdatingUser.create(0, userObject1));
expect(updateReturn).toEqual([
new ReturnedUser(
insertReturn.id,
userObject1.firstName,
userObject1.lastName,
userObject1.handle,
userObject1.email
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn[0].firstName);
});
it('transforms a union of updating object types', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser | Updateable<Users>) =>
source instanceof UpdatingUser
? {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}
: source,
});
const insertReturn = await mapper.insert().returnOne(userRow1);
// test with UpdatingUser
await mapper
.update({ id: insertReturn.id })
.columns(['name'])
.run(UpdatingUser.create(0, userObject1));
const readUser1 = await mapper.select(insertReturn.id).returnOne();
expect(readUser1).toEqual({
id: insertReturn.id,
name: `${userObject1.firstName} ${userObject1.lastName}`,
email: userRow1.email,
handle: userRow1.handle,
});
// test with Updateable<Users>
const newName = 'Suzanne Smith Something';
await mapper.update({ id: insertReturn.id }).run({ name: newName });
const readUser2 = await mapper.select(insertReturn.id).returnOne();
expect(readUser2).toEqual({
id: insertReturn.id,
name: newName,
email: userRow1.email,
handle: userRow1.handle,
});
});
});
|
src/tests/update-transform.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " expect(updateReturns).toEqual([{ id: 100 }]);\n const readUsers = await userMapperReturningID\n .select('id', '=', 100)\n .returnOne();\n expect(readUsers).toEqual({\n id: 100,\n name: 'Sue Rex',\n email: 'rex@abc.def',\n handle: USERS[0].handle,\n });",
"score": 0.9394826889038086
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " const updates = await userMapperReturningID.update().returnAll({\n name: 'Every User 1',\n });\n expect(updates).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);\n const update = await userMapperReturningID\n .update({ id: readUsers[0].id })\n .returnOne({\n name: 'Every User 2',\n });\n expect(update).toEqual({ id: 1 });",
"score": 0.937313973903656
},
{
"filename": "src/tests/update-general.test.ts",
"retrieved_chunk": " const expectedUsers = USERS.map((user, i) => ({\n id: insertReturns[i].id,\n h: user.handle,\n }));\n expect(updateReturns).toEqual(expectedUsers);\n const readUsers = await userMapperReturningID.select().returnAll();\n expect(readUsers.length).toEqual(3);\n for (const user of readUsers) {\n expect(user.email).toEqual(updateValues.email);\n }",
"score": 0.9352297782897949
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " user1\n );\n const expectedReturn3 = {\n id: insertReturns[2].id,\n firstName: user1.firstName,\n lastName: user1.lastName,\n };\n expect(success1).toBe(true);\n // verify updates\n const readUsers = await transformMapper.select().returnAll();",
"score": 0.931675910949707
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " .insert()\n .returnAll([userRow2, userRow3]);\n expect(insertReturns).toEqual([expectedUser2, expectedUser3]);\n // ensure return type can be accessed as a SelectedUser\n ((_: string) => {})(insertReturns[0].firstName);\n ((_: string) => {})(insertReturns[1].firstName);\n const readUsers = await transformMapper\n .select('id', '>', insertReturn.id)\n .returnAll();\n expect(readUsers).toEqual([expectedUser2, expectedUser3]);",
"score": 0.9311485290527344
}
] |
typescript
|
(qb) => qb.orderBy('id'))
.returnAll();
|
import { Kysely } from 'kysely';
import { TableMapper } from '../../mappers/table-mapper';
import { Database } from './test-tables';
import { InsertedUser } from './test-types';
const countTransform = (count: bigint) => Number(count);
export function createUserMapperReturningDefault(db: Kysely<Database>) {
return new TableMapper(db, 'users');
}
const noColumns = [] as const;
export function createUserMapperReturningNothing(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
keyColumns: noColumns,
updateReturnColumns: noColumns,
}).withTransforms({
countTransform,
});
}
export function createUserMapperReturningID(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
keyColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
countTransform,
});
}
export function createUserMapperReturningIDAndHandleAsH(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
keyColumns: ['id'],
insertReturnColumns: ['id', 'handle as h'],
updateReturnColumns: ['id', 'handle as h'],
}).withTransforms({ countTransform });
}
export function createUserMapperReturningDifferently(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
keyColumns: ['id'],
insertReturnColumns: ['id', 'handle'],
updateReturnColumns: ['name'],
}).withTransforms({ countTransform });
}
export function createUserMapperReturningAll(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
insertReturnColumns: ['*'],
updateReturnColumns: ['*'],
}).withTransforms({
countTransform,
});
}
export function createInsertTransformMapper(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email
|
: source.email,
}),
countTransform: (count) => Number(count),
});
|
}
|
src/tests/utils/test-mappers.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " updateReturnColumns: ['*'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,",
"score": 0.9527266621589661
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (user: MappedUser) => ({\n name: `${user.firstName} ${user.lastName}`,\n handle: user.handle,\n email: user.email,\n }),\n insertReturnTransform: (user, returns) =>\n new MappedUser(\n returns.id,",
"score": 0.9449142217636108
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(columns).toEqual(['*']);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n insertReturnTransform: (source: InsertedUser, returns) =>\n new ReturnedUser(\n returns.id,",
"score": 0.9365262985229492
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateTransform: (source: UpdatingUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n });\n const insertReturns = await mapper",
"score": 0.9315959215164185
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n updateReturnTransform: (source: User, returns) => ({\n id: returns.id,\n firstName: source.firstName,\n lastName: source.lastName,\n }),\n countTransform: (count) => Number(count),",
"score": 0.930686891078949
}
] |
typescript
|
: source.email,
}),
countTransform: (count) => Number(count),
});
|
import { Kysely } from 'kysely';
import { TableMapper } from '../../mappers/table-mapper';
import { Database } from './test-tables';
import { InsertedUser } from './test-types';
const countTransform = (count: bigint) => Number(count);
export function createUserMapperReturningDefault(db: Kysely<Database>) {
return new TableMapper(db, 'users');
}
const noColumns = [] as const;
export function createUserMapperReturningNothing(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
keyColumns: noColumns,
updateReturnColumns: noColumns,
}).withTransforms({
countTransform,
});
}
export function createUserMapperReturningID(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
keyColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
countTransform,
});
}
export function createUserMapperReturningIDAndHandleAsH(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
keyColumns: ['id'],
insertReturnColumns: ['id', 'handle as h'],
updateReturnColumns: ['id', 'handle as h'],
}).withTransforms({ countTransform });
}
export function createUserMapperReturningDifferently(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
keyColumns: ['id'],
insertReturnColumns: ['id', 'handle'],
updateReturnColumns: ['name'],
}).withTransforms({ countTransform });
}
export function createUserMapperReturningAll(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
insertReturnColumns: ['*'],
updateReturnColumns: ['*'],
}).withTransforms({
countTransform,
});
}
export function createInsertTransformMapper(db: Kysely<Database>) {
return new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source: InsertedUser) => ({
name: `${source.firstName} ${source.lastName}`,
handle:
|
source.handle,
email: source.email,
}),
countTransform: (count) => Number(count),
});
|
}
|
src/tests/utils/test-mappers.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " updateReturnColumns: ['*'],\n }).withTransforms({\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return new User(row.id, names[0], names[1], row.handle, row.email);\n },\n insertTransform: (source: User) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,",
"score": 0.9520299434661865
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " updateReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (user: MappedUser) => ({\n name: `${user.firstName} ${user.lastName}`,\n handle: user.handle,\n email: user.email,\n }),\n insertReturnTransform: (user, returns) =>\n new MappedUser(\n returns.id,",
"score": 0.9452551603317261
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(columns).toEqual(['*']);\n return {\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n };\n },\n insertReturnTransform: (source: InsertedUser, returns) =>\n new ReturnedUser(\n returns.id,",
"score": 0.9365205764770508
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " insertReturnColumns: ['id'],\n updateReturnColumns: ['id'],\n }).withTransforms({\n updateTransform: (source: UpdatingUser) => ({\n name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n });\n const insertReturns = await mapper",
"score": 0.9322191476821899
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " name: `${source.firstName} ${source.lastName}`,\n handle: source.handle,\n email: source.email,\n }),\n updateReturnTransform: (source: User, returns) => ({\n id: returns.id,\n firstName: source.firstName,\n lastName: source.lastName,\n }),\n countTransform: (count) => Number(count),",
"score": 0.9295139312744141
}
] |
typescript
|
source.handle,
email: source.email,
}),
countTransform: (count) => Number(count),
});
|
import { Kysely, Updateable } from 'kysely';
import { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database, Users } from './utils/test-tables';
import {
userObject1,
userRow1,
userRow2,
userRow3,
} from './utils/test-objects';
import { ReturnedUser, UpdatingUser } from './utils/test-types';
let db: Kysely<Database>;
beforeAll(async () => {
db = await createDB();
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating with transformation', () => {
it('transforms users for update without transforming return', async () => {
const mapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser) => ({
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}),
});
const insertReturns = await mapper
.insert()
.returnAll([userRow1, userRow2, userRow3]);
const updatingUser1 = UpdatingUser.create(
0,
Object.assign({}, userObject1, { firstName: 'Suzanne' })
);
const updateReturns = await mapper
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updatingUser1);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
const readUsers = await mapper
.select()
.modify((qb) => qb.orderBy('id'))
.returnAll();
expect(readUsers).toEqual([
Object.assign({}, userRow1, {
id: insertReturns[0].id,
name: 'Suzanne Smith',
}),
Object.assign({}, userRow2, { id: insertReturns[1].id }),
Object.assign({}, userRow1, {
id: insertReturns[2].id,
name: 'Suzanne Smith',
}),
]);
});
it('transforms update return into object without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
updateReturnTransform: (source, returns) =>
new ReturnedUser(
returns.id,
source.name ? source.name.split(' ')[0] : '(first)',
source.name ? source.name.split(' ')[1] : '(last)',
source.handle ? source.handle : '(handle)',
source.email ? source.email : '(email)'
),
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smith',
'(handle)',
'(email)'
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn1[0].firstName);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(
new ReturnedUser(
insertReturn.id,
'Suzanne',
'Smithy',
'(handle)',
'(email)'
)
);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn2!.firstName);
});
it('transforms update return into primitive without transforming update', async () => {
const updateReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
updateReturnTransform: (_source, returns) => returns.id,
});
const insertReturn = await updateReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn1 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnAll({ name: 'Suzanne Smith' });
expect(updateReturn1).toEqual([1]);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn1[0]);
const updateReturn2 = await updateReturnTransformMapper
.update({ id: insertReturn })
.returnOne({ name: 'Suzanne Smithy' });
expect(updateReturn2).toEqual(1);
// Ensure the returned value is accessible as a number
((_: number) => {})(updateReturn2!);
});
it("transforms update and update return, columns is ['*']", async () => {
expect.assertions(2);
const updateAndReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
updateReturnColumns: ['id'],
}).withTransforms({
|
updateTransform: (source: UpdatingUser, columns) => {
|
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
updateReturnTransform: (source: UpdatingUser, returns) =>
new ReturnedUser(
returns.id,
source.firstName,
source.lastName,
source.handle,
source.email
),
});
const insertReturn = await updateAndReturnTransformMapper
.insert()
.returnOne(userRow1);
const updateReturn = await updateAndReturnTransformMapper
.update({ id: insertReturn.id })
.returnAll(UpdatingUser.create(0, userObject1));
expect(updateReturn).toEqual([
new ReturnedUser(
insertReturn.id,
userObject1.firstName,
userObject1.lastName,
userObject1.handle,
userObject1.email
),
]);
// Ensure the returned value is accessible as a ReturnedUser
((_: string) => {})(updateReturn[0].firstName);
});
it('transforms a union of updating object types', async () => {
const mapper = new TableMapper(db, 'users', {
keyColumns: ['id'],
}).withTransforms({
updateTransform: (source: UpdatingUser | Updateable<Users>) =>
source instanceof UpdatingUser
? {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
}
: source,
});
const insertReturn = await mapper.insert().returnOne(userRow1);
// test with UpdatingUser
await mapper
.update({ id: insertReturn.id })
.columns(['name'])
.run(UpdatingUser.create(0, userObject1));
const readUser1 = await mapper.select(insertReturn.id).returnOne();
expect(readUser1).toEqual({
id: insertReturn.id,
name: `${userObject1.firstName} ${userObject1.lastName}`,
email: userRow1.email,
handle: userRow1.handle,
});
// test with Updateable<Users>
const newName = 'Suzanne Smith Something';
await mapper.update({ id: insertReturn.id }).run({ name: newName });
const readUser2 = await mapper.select(insertReturn.id).returnOne();
expect(readUser2).toEqual({
id: insertReturn.id,
name: newName,
email: userRow1.email,
handle: userRow1.handle,
});
});
});
|
src/tests/update-transform.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(insertReturns).toEqual([2, 3]);\n // ensure return type can be accessed as a number\n ((_: number) => {})(insertReturns[0]);\n });\n it(\"transforms insertion and insertion return, columns is ['*']\", async () => {\n expect.assertions(5);\n const insertAndReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n insertTransform: (source: InsertedUser, columns) => {",
"score": 0.9422021508216858
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });\n // ensure return type can be accessed as a row\n ((_: string) => {})(updatedUser!.name);\n });\n it('transforms insertion return into primitive without transforming insertion', async () => {\n const insertReturnTransformMapper = new TableMapper(db, 'users', {\n insertReturnColumns: ['id'],\n }).withTransforms({\n insertReturnTransform: (_source, returns) => returns.id,\n countTransform: (count) => Number(count),",
"score": 0.9274669289588928
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " // test that updates return rows\n const updateReturn = await transformMapper\n .update({ id: 1 })\n .returnOne(expectedUser2);\n expect(updateReturn).toEqual({\n id: 1,\n name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,\n });\n // ensure return type can be accessed as a row\n ((_: string) => {})(updateReturn!.name);",
"score": 0.9233582615852356
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " // Ensure that the provided columns are accessible\n ((_: string) => {})(updateReturn1!.firstName);\n const readUser1 = await transformMapper\n .select({ id: insertReturns[2].id })\n .returnOne();\n expect(readUser1).toEqual(expectedUser1);\n // test returnAll()\n const updateReturn2 = await compilation.returnAll({}, user2);\n const expectedUser2 = User.create(insertReturns[2].id, {\n firstName: user2.firstName,",
"score": 0.9230437278747559
},
{
"filename": "src/tests/transform-types.test.ts",
"retrieved_chunk": " });\n });\n ignore('detects invalid update return transform return', async () => {\n const mapper = new TableMapper(db, 'users', { keyColumns: ['id'] });\n mapper.withTransforms({\n selectTransform: (_user) => new User(1, 'John', 'Doe', 'jdoe', 'x@y.z'),\n updateTransform: (user: User) => ({\n id: user.id,\n name: `${user.firstName} ${user.lastName}`,\n handle: user.handle,",
"score": 0.9133058786392212
}
] |
typescript
|
updateTransform: (source: UpdatingUser, columns) => {
|
import { Kysely, sql } from 'kysely';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { Database } from './utils/test-tables';
import {
createUserMapperReturningDefault,
createUserMapperReturningID,
createUserMapperReturningIDAndHandleAsH,
createUserMapperReturningAll,
createUserMapperReturningNothing,
} from './utils/test-mappers';
import { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
let db: Kysely<Database>;
let userMapperReturningDefault: ReturnType<
typeof createUserMapperReturningDefault
>;
let userMapperReturningNothing: ReturnType<
typeof createUserMapperReturningNothing
>;
let userMapperReturningID: ReturnType<typeof createUserMapperReturningID>;
let userMapperReturningIDAndHandleAsH: ReturnType<
typeof createUserMapperReturningIDAndHandleAsH
>;
let userMapperReturningAll: ReturnType<typeof createUserMapperReturningAll>;
beforeAll(async () => {
db = await createDB();
userMapperReturningDefault = createUserMapperReturningDefault(db);
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningID = createUserMapperReturningID(db);
userMapperReturningIDAndHandleAsH =
createUserMapperReturningIDAndHandleAsH(db);
userMapperReturningAll = createUserMapperReturningAll(db);
});
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('general update', () => {
it('updates nothing returning zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const success = await userMapperReturningAll
.update({ id: 1 })
.run(updateValues);
expect(success).toBe(false);
const updateCount = await userMapperReturningAll
.update({ id: 1 })
.returnCount(updateValues);
expect(updateCount).toEqual(0);
const updates = await userMapperReturningID
.update({ id: 1 })
.returnAll(updateValues);
expect(updates.length).toEqual(0);
const update = await userMapperReturningID
.update({ id: 1 })
.returnOne(updateValues);
expect(update).toBeNull();
});
it('updates something returning non-zero update count', async () => {
const updateValues = { email: 'new.email@xyz.pdq' };
const insertReturn0 = await userMapperReturningID
.insert()
.returnOne(USERS[0]);
await userMapperReturningID.insert().run(USERS[1]);
await userMapperReturningID.insert().run(USERS[2]);
const updateCount1 = await userMapperReturningAll
.update({ id: insertReturn0.id })
.returnCount(updateValues);
expect(updateCount1).toEqual(1);
const readUser1 = await userMapperReturningID
.select('id', '=', insertReturn0.id)
.returnOne();
expect(readUser1?.email).toEqual(updateValues.email);
const updateCount2 = await userMapperReturningAll
.update({ name: 'Sue' })
.returnCount(updateValues);
expect(updateCount2).toEqual(2);
const readUsers = await userMapperReturningID
.select('name', '=', 'Sue')
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].email).toEqual(updateValues.email);
expect(readUsers[1].email).toEqual(updateValues.email);
const updates = await userMapperReturningID.update().returnAll({
name: 'Every User 1',
});
expect(updates).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
const update = await userMapperReturningID
.update({ id: readUsers[0].id })
.returnOne({
name: 'Every User 2',
});
expect(update).toEqual({ id: 1 });
const readUser2 = await userMapperReturningID
.select('id', '=', 1)
.returnOne();
expect(readUser2?.name).toEqual('Every User 2');
const updateCount = await userMapperReturningID.update().returnCount({
name: 'Every User 3',
});
expect(updateCount).toEqual(3);
const success = await userMapperReturningID.update().run({
name: 'Every User 4',
});
expect(success).toBe(true);
});
it('updates returning configured return columns', async () => {
await userMapperReturningID.insert().run(USERS[0]);
const insertReturn = await userMapperReturningID
.insert()
.returnOne(USERS[1]);
await userMapperReturningID.insert().run(USERS[2]);
// Verify that update performs the correct change on the correct row.
const updateValues1 = { email: 'new.email@xyz.pdq' };
const updateReturns1 = await userMapperReturningID
.update({ id: insertReturn.id })
.returnAll(updateValues1);
expect(updateReturns1).toEqual([{ id: insertReturn.id }]);
let readUser = await userMapperReturningID
.select('id', '=', insertReturn.id)
.returnOne();
expect(readUser?.email).toEqual(updateValues1.email);
// Verify a different change on the same row, returning multiple columns.
const updateValues2 = { name: 'Sue' };
const updateReturns2 = await userMapperReturningIDAndHandleAsH
.update({ email: updateValues1.email })
.returnAll(updateValues2);
updateReturns2[0].id; // ensure key is accessible
updateReturns2[0].h; // ensure key is accessible
expect(updateReturns2).toEqual([
{
id: insertReturn.id,
h: USERS[1].handle,
},
]);
readUser = await userMapperReturningID
.select('id', '=', insertReturn.id)
.returnOne();
expect(readUser?.name).toEqual(updateValues2.name);
// Verify that update changes all required rows.
const updateValues3 = { name: 'Replacement Sue' };
const updateReturns3 = await userMapperReturningIDAndHandleAsH
.update({ name: 'Sue' })
.returnAll(updateValues3);
expect(updateReturns3.length).toEqual(3);
expect(updateReturns3[0].h).toEqual(USERS[0].handle);
expect(updateReturns3[1].h).toEqual(USERS[1].handle);
expect(updateReturns3[2].h).toEqual(USERS[2].handle);
const readUsers = await userMapperReturningID
.select('name', '=', updateValues3.name)
.returnAll();
expect(readUsers.length).toEqual(3);
ignore('check return types', () => {
// @ts-expect-error - check return types
updateReturns2[0].title;
// @ts-expect-error - check return types
updateReturns2[0].userId;
});
});
it('update returns void when defaulting to no return columns', async () => {
await userMapperReturningID.insert().run(USERS);
const updates = await userMapperReturningDefault
.update({ name: 'Sue' })
.returnAll({ email: 'new.email@xyz.pdq' });
expect(updates).toBeUndefined();
const readUsers = await userMapperReturningID
.select({
email: 'new.email@xyz.pdq',
})
.returnAll();
expect(readUsers.length).toEqual(2);
});
it('update returns void when explicitly no return columns', async () => {
await userMapperReturningID.insert().run(USERS);
const updates = await userMapperReturningNothing
.update({ name: 'Sue' })
.returnAll({ email: 'new.email@xyz.pdq' });
expect(updates).toBeUndefined();
const readUsers = await userMapperReturningID
.select({
email: 'new.email@xyz.pdq',
})
.returnAll();
expect(readUsers.length).toEqual(2);
const update = await userMapperReturningNothing
.update({ name: 'Sue' })
.returnOne({ email: 'new2.email@xyz.pdq' });
expect(update).toBeUndefined();
const readUser = await userMapperReturningID
.select({
email: 'new2.email@xyz.pdq',
})
.returnOne();
expect(readUser!.id).toEqual(1);
ignore('type errors', () => {
// @ts-expect-error - check return types
updates[0].id;
// @ts-expect-error - check return types
update!.id;
});
});
it('updates configured to return all columns', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues1 = { email: 'new.email@xyz.pdq' };
const updateReturns = await userMapperReturningAll
.update({ name: 'Sue' })
.returnAll(updateValues1);
const expectedUsers = [
Object.assign({}, USERS[0], updateValues1, { id: insertReturns[0].id }),
Object.assign({}, USERS[2], updateValues1, { id: insertReturns[2].id }),
];
expect(updateReturns).toEqual(expectedUsers);
// Ensure that the returned value can be accessed as a row.
((_: string) => {})(updateReturns[0].name);
((_: string | null) => {})(updateReturns[0].email);
const updateValues2 = { email: 'another.email@xyz.pdq' };
const updateReturn = await userMapperReturningAll
.update({ name: 'Sue' })
.returnOne(updateValues2);
const expectedUser = Object.assign({}, USERS[0], updateValues2, {
id: insertReturns[0].id,
});
expect(updateReturn).toEqual(expectedUser);
// Ensure that the returned value can be accessed as a row.
((_: string) => {})(updateReturn!.name);
((_: string | null) => {})(updateReturn!.email);
});
it('updates all rows when no filter is given', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { email: 'new.email@xyz.pdq' };
const updateReturns = await userMapperReturningIDAndHandleAsH
.update()
.returnAll(updateValues);
const expectedUsers = USERS.map((user
|
, i) => ({
|
id: insertReturns[i].id,
h: user.handle,
}));
expect(updateReturns).toEqual(expectedUsers);
const readUsers = await userMapperReturningID.select().returnAll();
expect(readUsers.length).toEqual(3);
for (const user of readUsers) {
expect(user.email).toEqual(updateValues.email);
}
});
it('updates rows indicated by a binary operator', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { email: 'new.email@xyz.pdq' };
const updateCount = await userMapperReturningAll
.update('id', '>', insertReturns[0].id)
.returnCount(updateValues);
expect(updateCount).toEqual(2);
const readUsers = await userMapperReturningID
.select('id', '>', insertReturns[0].id)
.returnAll();
expect(readUsers.length).toEqual(2);
for (const user of readUsers) {
expect(user.email).toEqual(updateValues.email);
}
});
it('updates rows indicated by a kysely expression', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues = { email: 'new.email@xyz.pdq' };
const updateCount = await userMapperReturningDefault
.update(sql`id > ${insertReturns[0].id}`)
.returnCount(updateValues);
expect(updateCount).toEqual(BigInt(2));
const readUsers = await userMapperReturningID
.select('id', '>', insertReturns[0].id)
.returnAll();
expect(readUsers.length).toEqual(2);
for (const user of readUsers) {
expect(user.email).toEqual(updateValues.email);
}
});
it('updates rows indicated by a where expression filter', async () => {
const insertReturns = await userMapperReturningID.insert().returnAll(USERS);
const updateValues1 = { email: 'foo@xyz.pdq' };
const updateCount = await userMapperReturningAll
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnCount(updateValues1);
expect(updateCount).toEqual(2);
const updateValues2 = { email: 'bar@xyz.pdq' };
const updateReturns = await userMapperReturningID
.update(({ or, cmpr }) =>
or([
cmpr('id', '=', insertReturns[0].id),
cmpr('id', '=', insertReturns[2].id),
])
)
.returnAll(updateValues2);
expect(updateReturns).toEqual([
{ id: insertReturns[0].id },
{ id: insertReturns[2].id },
]);
});
ignore('detects update type errors', async () => {
userMapperReturningID.update(
// @ts-expect-error - table must have all filter fields
{ notThere: 'xyz' }
);
// @ts-expect-error - table must have all filter fields
userMapperReturningID.update('notThere', '=', 'foo');
userMapperReturningID.update(({ or, cmpr }) =>
// @ts-expect-error - only table columns are accessible via anyOf()
or([cmpr('notThere', '=', 'xyz'), cmpr('alsoNotThere', '=', 'Sue')])
);
// @ts-expect-error - ID filter must have correct type
userMapperReturningID.update('str');
// @ts-expect-error - ID filter must have correct type
userMapperReturningID.update(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.update(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.update([1]);
userMapperReturningID.update({ id: 32 }).returnAll(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).returnAll(USERS[0]))[0].name;
userMapperReturningID.update({ id: 32 }).returnOne(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).returnOne(USERS[0]))[0].name;
userMapperReturningID.update({ id: 32 }).returnCount(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).returnCount(USERS[0]))[0].name;
userMapperReturningID.update({ id: 32 }).run(
// @ts-expect-error - update must only have table columns
{ notThere: 'xyz@pdq.xyz' }
);
// @ts-expect-error - only requested columns are accessible
// prettier-ignore
(await userMapperReturningID.update({ id: 32 }).run(USERS[0]))[0].name;
});
});
|
src/tests/update-general.test.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " handle: USERS[0].handle,\n });\n });\n it('subsets updating columns, including ID', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const updateValues = { id: 100, name: 'Sue Rex', email: 'rex@abc.def' };\n const subsetQuery = userMapperReturningID\n .update('id', '=', insertReturns[0].id)\n .columns(['id', 'name', 'email']);\n const updateReturns = await subsetQuery.returnAll(updateValues);",
"score": 0.9144477248191833
},
{
"filename": "src/tests/insert-array.test.ts",
"retrieved_chunk": " // @ts-expect-error - check return types\n updateReturns[0].userId;\n });\n });\n it('inserts multiple returning no columns by default', async () => {\n const insertReturns = await userMapperReturningDefault\n .insert()\n .returnAll(USERS);\n expect(insertReturns).toBeUndefined();\n const readUsers = await userMapperReturningAll.select().returnAll();",
"score": 0.9124306440353394
},
{
"filename": "src/tests/update-compile.test.ts",
"retrieved_chunk": " );\n });\n });\n it('requires all indicated columns to be updated', async () => {\n await userMapperReturningID.insert().run(USERS);\n const compilation = userMapperReturningID\n .update()\n .columns(['name', 'handle', 'email'])\n .compile();\n const updateValues = { name: 'John Doe', handle: 'johndoe' };",
"score": 0.9100708365440369
},
{
"filename": "src/tests/update-columns.test.ts",
"retrieved_chunk": " });\n it('requires all subsetted columns to be updated', async () => {\n const insertReturns = await userMapperReturningID.insert().returnAll(USERS);\n const updateValues = { name: 'Sue Rex' };\n const subsetQuery = userMapperReturningID\n .update('id', '=', insertReturns[0].id)\n .columns(['name', 'email']);\n expect(() => subsetQuery.returnAll(updateValues)).rejects.toThrow(\n `column 'email' missing`\n );",
"score": 0.9089503288269043
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " const updateReturn3 = await userMapper\n .update()\n .columns(['name', 'handle', 'email'])\n .returnAll(updatingUser3);\n expect(updateReturn3).toEqual([\n { ...updatingUser3, id: 1 },\n { ...updatingUser3, id: 10 },\n ]);\n updateReturn3[0].id; // ensure 'id' is accessible\n updateReturn3[0].name; // ensure 'name' is accessible",
"score": 0.9078367352485657
}
] |
typescript
|
, i) => ({
|
import { Insertable } from 'kysely';
import { Users, Posts } from './test-tables';
import { InsertedUser, ReturnedUser, SelectedUser } from './test-types';
export const USERS: Insertable<Users>[] = [
{
handle: 'handle1',
name: 'Sue',
email: 'foo1@bar.com',
},
{
handle: 'handle2',
name: 'Fred',
email: 'foo2@bar.com',
},
{
handle: 'handle3',
name: 'Sue',
email: 'foo3@bar.com',
},
];
export const POSTS: Insertable<Posts>[] = [
{
userId: 0,
title: 'About Something',
likeCount: 0,
},
{
userId: 0,
title: 'And Another Thing',
likeCount: 10,
},
{
userId: 0,
title: 'Still One More Thing',
likeCount: 1000,
},
];
export const userRow1 = {
name: 'John Smith',
handle: 'jsmith',
email: 'jsmith@xyz.pdq',
};
export const userRow2 = {
name: 'Jane Doe',
handle: 'jdoe',
email: 'jdoe@xyz.pdq',
};
export const userRow3 = {
name: 'Mary Sue',
handle: 'msue',
email: 'msue@xyz.pdq',
};
export const userObject1 = {
firstName: 'John',
lastName: 'Smith',
handle: userRow1.handle,
email: userRow1.email,
};
export const userObject2 = {
firstName: 'Jane',
lastName: 'Doe',
handle: userRow2.handle,
email: userRow2.email,
};
export const userObject3 = {
firstName: 'Mary',
lastName: 'Sue',
handle: userRow3.handle,
email: userRow3.email,
};
export const selectedUser1 = SelectedUser.create(1, userObject1);
export const selectedUser2 = SelectedUser.create(2, userObject2);
export const selectedUser3 = SelectedUser.create(3, userObject3);
export const insertedUser1 = InsertedUser.create(0, userObject1);
export const insertedUser2 = InsertedUser.create(0, userObject2);
export const insertedUser3 = InsertedUser.create(0, userObject3);
export
|
const insertReturnedUser1 = ReturnedUser.create(1, userObject1);
|
export const insertReturnedUser2 = ReturnedUser.create(2, userObject2);
export const insertReturnedUser3 = ReturnedUser.create(3, userObject3);
|
src/tests/utils/test-objects.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " id: insertReturn.id,\n })\n .returnOne();\n expect(readUser).toEqual(expectedUser1);\n // test returnAll()\n const names2 = userRow2.name.split(' ');\n const expectedUser2 = SelectedUser.create(2, {\n firstName: names2[0],\n lastName: names2[1],\n handle: userRow2.handle,",
"score": 0.9042994976043701
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " email: userRow2.email,\n });\n const names3 = userRow3.name.split(' ');\n const expectedUser3 = SelectedUser.create(3, {\n firstName: names3[0],\n lastName: names3[1],\n handle: userRow3.handle,\n email: userRow3.email,\n });\n const insertReturns = await transformMapper",
"score": 0.898446798324585
},
{
"filename": "src/tests/update-transform.test.ts",
"retrieved_chunk": " .insert()\n .returnAll([userRow1, userRow2, userRow3]);\n const updatingUser1 = UpdatingUser.create(\n 0,\n Object.assign({}, userObject1, { firstName: 'Suzanne' })\n );\n const updateReturns = await mapper\n .update(({ or, cmpr }) =>\n or([\n cmpr('id', '=', insertReturns[0].id),",
"score": 0.8919329643249512
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " .select({ id: insertReturn1.id })\n .returnOne();\n expect(selectedUser4).toEqual(updatingUser2);\n // test updating multiple users returning rows\n const updatingUser3 = new MappedUser(\n selectedUser1!.id,\n 'Everyone',\n selectedUser1!.handle,\n selectedUser1!.email\n );",
"score": 0.8899967670440674
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names[1],\n handle: row.handle,\n email: row.email,\n });\n },\n });\n // test returnOne()\n const names1 = userRow1.name.split(' ');\n const expectedUser1 = SelectedUser.create(1, {\n firstName: names1[0],",
"score": 0.8893206715583801
}
] |
typescript
|
const insertReturnedUser1 = ReturnedUser.create(1, userObject1);
|
import { Insertable } from 'kysely';
import { Users, Posts } from './test-tables';
import { InsertedUser, ReturnedUser, SelectedUser } from './test-types';
export const USERS: Insertable<Users>[] = [
{
handle: 'handle1',
name: 'Sue',
email: 'foo1@bar.com',
},
{
handle: 'handle2',
name: 'Fred',
email: 'foo2@bar.com',
},
{
handle: 'handle3',
name: 'Sue',
email: 'foo3@bar.com',
},
];
export const POSTS: Insertable<Posts>[] = [
{
userId: 0,
title: 'About Something',
likeCount: 0,
},
{
userId: 0,
title: 'And Another Thing',
likeCount: 10,
},
{
userId: 0,
title: 'Still One More Thing',
likeCount: 1000,
},
];
export const userRow1 = {
name: 'John Smith',
handle: 'jsmith',
email: 'jsmith@xyz.pdq',
};
export const userRow2 = {
name: 'Jane Doe',
handle: 'jdoe',
email: 'jdoe@xyz.pdq',
};
export const userRow3 = {
name: 'Mary Sue',
handle: 'msue',
email: 'msue@xyz.pdq',
};
export const userObject1 = {
firstName: 'John',
lastName: 'Smith',
handle: userRow1.handle,
email: userRow1.email,
};
export const userObject2 = {
firstName: 'Jane',
lastName: 'Doe',
handle: userRow2.handle,
email: userRow2.email,
};
export const userObject3 = {
firstName: 'Mary',
lastName: 'Sue',
handle: userRow3.handle,
email: userRow3.email,
};
export const selectedUser1 = SelectedUser.create(1, userObject1);
export const selectedUser2 = SelectedUser.create(2, userObject2);
export const selectedUser3 = SelectedUser.create(3, userObject3);
export const insertedUser1 =
|
InsertedUser.create(0, userObject1);
|
export const insertedUser2 = InsertedUser.create(0, userObject2);
export const insertedUser3 = InsertedUser.create(0, userObject3);
export const insertReturnedUser1 = ReturnedUser.create(1, userObject1);
export const insertReturnedUser2 = ReturnedUser.create(2, userObject2);
export const insertReturnedUser3 = ReturnedUser.create(3, userObject3);
|
src/tests/utils/test-objects.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names[1],\n handle: row.handle,\n email: row.email,\n });\n },\n });\n // test returnOne()\n const names1 = userRow1.name.split(' ');\n const expectedUser1 = SelectedUser.create(1, {\n firstName: names1[0],",
"score": 0.9053488373756409
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " email: userRow2.email,\n });\n const names3 = userRow3.name.split(' ');\n const expectedUser3 = SelectedUser.create(3, {\n firstName: names3[0],\n lastName: names3[1],\n handle: userRow3.handle,\n email: userRow3.email,\n });\n const insertReturns = await transformMapper",
"score": 0.8949181437492371
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " id: insertReturn.id,\n })\n .returnOne();\n expect(readUser).toEqual(expectedUser1);\n // test returnAll()\n const names2 = userRow2.name.split(' ');\n const expectedUser2 = SelectedUser.create(2, {\n firstName: names2[0],\n lastName: names2[1],\n handle: userRow2.handle,",
"score": 0.8910952806472778
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names1[1],\n handle: userRow1.handle,\n email: userRow1.email,\n });\n const insertReturn = await transformMapper.insert().returnOne(userRow1);\n expect(insertReturn).toEqual(expectedUser1);\n // ensure return type can be accessed as a SelectedUser\n ((_: string) => {})(insertReturn.firstName);\n const readUser = await transformMapper\n .select({",
"score": 0.8880318403244019
},
{
"filename": "src/tests/sample-mappers.test.ts",
"retrieved_chunk": " .select({ id: insertReturn1.id })\n .returnOne();\n expect(selectedUser4).toEqual(updatingUser2);\n // test updating multiple users returning rows\n const updatingUser3 = new MappedUser(\n selectedUser1!.id,\n 'Everyone',\n selectedUser1!.handle,\n selectedUser1!.email\n );",
"score": 0.8761894702911377
}
] |
typescript
|
InsertedUser.create(0, userObject1);
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
|
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
|
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": "import { PreAuthorizeMiddleware, Middleware } from \"./middleware\";\n// deno-lint-ignore require-await\nexport const urlVerification: PreAuthorizeMiddleware = async (req) => {\n if (req.body.type === \"url_verification\") {\n return { status: 200, body: req.body.challenge };\n }\n};\nconst eventTypesToKeep = [\"member_joined_channel\", \"member_left_channel\"];\n// deno-lint-ignore require-await\nexport const ignoringSelfEvents: Middleware = async (req) => {",
"score": 0.8634397983551025
},
{
"filename": "src/context/context.ts",
"retrieved_chunk": " // deno-lint-ignore no-explicit-any\n [key: string]: any; // custom properties\n };\n}\nexport type SlackAppContext = {\n client: SlackAPIClient;\n botToken: string;\n userToken?: string;\n authorizeResult: AuthorizeResult;\n} & PreAuthorizeSlackAppContext;",
"score": 0.8488881587982178
},
{
"filename": "src/socket-mode/socket-mode-client.ts",
"retrieved_chunk": " public appLevelToken: string;\n public ws: WebSocket | undefined;\n constructor(\n // deno-lint-ignore no-explicit-any\n app: SlackApp<any>\n ) {\n if (!app.socketMode) {\n throw new ConfigError(\n \"socketMode: true must be set for running with Socket Mode\"\n );",
"score": 0.8460842370986938
},
{
"filename": "src/oauth/installation.ts",
"retrieved_chunk": " bot_scopes?: string[];\n bot_refresh_token?: string; // token rotation\n bot_token_expires_at?: number; // token rotation (epoch time seconds)\n // user token\n user_token?: string;\n user_scopes?: string[];\n user_refresh_token?: string; // token rotation\n user_token_expires_at?: number; // token rotation (epoch time seconds)\n // Only when having incoming-webhooks\n incoming_webhook_url?: string;",
"score": 0.8428805470466614
},
{
"filename": "src/authorization/authorize-result.ts",
"retrieved_chunk": " user?: string;\n userToken?: string;\n userScopes?: string[];\n}",
"score": 0.8390440940856934
}
] |
typescript
|
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
|
import { Insertable } from 'kysely';
import { Users, Posts } from './test-tables';
import { InsertedUser, ReturnedUser, SelectedUser } from './test-types';
export const USERS: Insertable<Users>[] = [
{
handle: 'handle1',
name: 'Sue',
email: 'foo1@bar.com',
},
{
handle: 'handle2',
name: 'Fred',
email: 'foo2@bar.com',
},
{
handle: 'handle3',
name: 'Sue',
email: 'foo3@bar.com',
},
];
export const POSTS: Insertable<Posts>[] = [
{
userId: 0,
title: 'About Something',
likeCount: 0,
},
{
userId: 0,
title: 'And Another Thing',
likeCount: 10,
},
{
userId: 0,
title: 'Still One More Thing',
likeCount: 1000,
},
];
export const userRow1 = {
name: 'John Smith',
handle: 'jsmith',
email: 'jsmith@xyz.pdq',
};
export const userRow2 = {
name: 'Jane Doe',
handle: 'jdoe',
email: 'jdoe@xyz.pdq',
};
export const userRow3 = {
name: 'Mary Sue',
handle: 'msue',
email: 'msue@xyz.pdq',
};
export const userObject1 = {
firstName: 'John',
lastName: 'Smith',
handle: userRow1.handle,
email: userRow1.email,
};
export const userObject2 = {
firstName: 'Jane',
lastName: 'Doe',
handle: userRow2.handle,
email: userRow2.email,
};
export const userObject3 = {
firstName: 'Mary',
lastName: 'Sue',
handle: userRow3.handle,
email: userRow3.email,
};
export const selectedUser1
|
= SelectedUser.create(1, userObject1);
|
export const selectedUser2 = SelectedUser.create(2, userObject2);
export const selectedUser3 = SelectedUser.create(3, userObject3);
export const insertedUser1 = InsertedUser.create(0, userObject1);
export const insertedUser2 = InsertedUser.create(0, userObject2);
export const insertedUser3 = InsertedUser.create(0, userObject3);
export const insertReturnedUser1 = ReturnedUser.create(1, userObject1);
export const insertReturnedUser2 = ReturnedUser.create(2, userObject2);
export const insertReturnedUser3 = ReturnedUser.create(3, userObject3);
|
src/tests/utils/test-objects.ts
|
jtlapp-kysely-mapper-9fd878b
|
[
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names[1],\n handle: row.handle,\n email: row.email,\n });\n },\n });\n // test returnOne()\n const names1 = userRow1.name.split(' ');\n const expectedUser1 = SelectedUser.create(1, {\n firstName: names1[0],",
"score": 0.9134238958358765
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " email: userRow2.email,\n });\n const names3 = userRow3.name.split(' ');\n const expectedUser3 = SelectedUser.create(3, {\n firstName: names3[0],\n lastName: names3[1],\n handle: userRow3.handle,\n email: userRow3.email,\n });\n const insertReturns = await transformMapper",
"score": 0.8990123271942139
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " id: insertReturn.id,\n })\n .returnOne();\n expect(readUser).toEqual(expectedUser1);\n // test returnAll()\n const names2 = userRow2.name.split(' ');\n const expectedUser2 = SelectedUser.create(2, {\n firstName: names2[0],\n lastName: names2[1],\n handle: userRow2.handle,",
"score": 0.8790158629417419
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " lastName: names1[1],\n handle: userRow1.handle,\n email: userRow1.email,\n });\n const insertReturn = await transformMapper.insert().returnOne(userRow1);\n expect(insertReturn).toEqual(expectedUser1);\n // ensure return type can be accessed as a SelectedUser\n ((_: string) => {})(insertReturn.firstName);\n const readUser = await transformMapper\n .select({",
"score": 0.8780133724212646
},
{
"filename": "src/tests/insert-transforms.test.ts",
"retrieved_chunk": " handle: source.handle,\n email: source.email,\n };\n }\n return source;\n },\n selectTransform: (row) => {\n const names = row.name.split(' ');\n return SelectedUser.create(row.id, {\n firstName: names[0],",
"score": 0.8763456344604492
}
] |
typescript
|
= SelectedUser.create(1, userObject1);
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) =>
|
SlackHandler<E, SlackEvent<string>> | null)[] = [];
|
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": "import { PreAuthorizeMiddleware, Middleware } from \"./middleware\";\n// deno-lint-ignore require-await\nexport const urlVerification: PreAuthorizeMiddleware = async (req) => {\n if (req.body.type === \"url_verification\") {\n return { status: 200, body: req.body.challenge };\n }\n};\nconst eventTypesToKeep = [\"member_joined_channel\", \"member_left_channel\"];\n// deno-lint-ignore require-await\nexport const ignoringSelfEvents: Middleware = async (req) => {",
"score": 0.8539252281188965
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n // deno-lint-ignore no-explicit-any\n body: Record<string, any>;\n retryNum?: number;\n retryReason?: string;\n rawBody: string;\n headers: Headers;\n}\nexport type PreAuthorizeSlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {",
"score": 0.8452247381210327
},
{
"filename": "src/context/context.ts",
"retrieved_chunk": " // deno-lint-ignore no-explicit-any\n [key: string]: any; // custom properties\n };\n}\nexport type SlackAppContext = {\n client: SlackAPIClient;\n botToken: string;\n userToken?: string;\n authorizeResult: AuthorizeResult;\n} & PreAuthorizeSlackAppContext;",
"score": 0.8394019603729248
},
{
"filename": "src/middleware/middleware.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport {\n PreAuthorizeSlackMiddlwareRequest,\n SlackMiddlwareRequest,\n} from \"../request/request\";\nimport { SlackResponse } from \"../response/response\";\nexport type PreAuthorizeMiddleware<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<SlackResponse | void>;\nexport type Middleware<E extends SlackAppEnv = SlackAppEnv> = (",
"score": 0.8298125267028809
},
{
"filename": "src/request/request-body.ts",
"retrieved_chunk": "export interface SlackRequestBody {\n type?: string;\n // slash commands\n command?: string;\n // event_callback\n event?: {\n type: string;\n subtype?: string;\n text?: string;\n };",
"score": 0.8279056549072266
}
] |
typescript
|
SlackHandler<E, SlackEvent<string>> | null)[] = [];
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
|
authorize?: Authorize<E>;
|
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/authorization/authorize.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport { PreAuthorizeSlackMiddlwareRequest } from \"../request/request\";\nimport { AuthorizeResult } from \"./authorize-result\";\nexport type Authorize<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<AuthorizeResult>;",
"score": 0.8795723915100098
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": "import {\n SlackAppContext,\n PreAuthorizeSlackAppContext,\n SlackAppContextWithRespond,\n SlackAppContextWithOptionalRespond,\n SlackAppContextWithChannelId,\n} from \"../context/context\";\nimport { SlackAppEnv } from \"../app-env\";\nexport interface SlackMiddlewareRequestBase<E extends SlackAppEnv> {\n env: E;",
"score": 0.8698769807815552
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.86858731508255
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": "import {\n InstallationError,\n MissingCode,\n CompletionPageError,\n InstallationStoreError,\n OpenIDConnectError,\n} from \"./oauth/error-codes\";\nexport interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {\n env: E;\n installationStore: InstallationStore<E>;",
"score": 0.868003249168396
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8655127286911011
}
] |
typescript
|
authorize?: Authorize<E>;
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body:
|
SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
|
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": "import { PreAuthorizeMiddleware, Middleware } from \"./middleware\";\n// deno-lint-ignore require-await\nexport const urlVerification: PreAuthorizeMiddleware = async (req) => {\n if (req.body.type === \"url_verification\") {\n return { status: 200, body: req.body.challenge };\n }\n};\nconst eventTypesToKeep = [\"member_joined_channel\", \"member_left_channel\"];\n// deno-lint-ignore require-await\nexport const ignoringSelfEvents: Middleware = async (req) => {",
"score": 0.8801685571670532
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n // deno-lint-ignore no-explicit-any\n body: Record<string, any>;\n retryNum?: number;\n retryReason?: string;\n rawBody: string;\n headers: Headers;\n}\nexport type PreAuthorizeSlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {",
"score": 0.8431159257888794
},
{
"filename": "src/middleware/middleware.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport {\n PreAuthorizeSlackMiddlwareRequest,\n SlackMiddlwareRequest,\n} from \"../request/request\";\nimport { SlackResponse } from \"../response/response\";\nexport type PreAuthorizeMiddleware<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<SlackResponse | void>;\nexport type Middleware<E extends SlackAppEnv = SlackAppEnv> = (",
"score": 0.840539813041687
},
{
"filename": "src/context/context.ts",
"retrieved_chunk": " // deno-lint-ignore no-explicit-any\n [key: string]: any; // custom properties\n };\n}\nexport type SlackAppContext = {\n client: SlackAPIClient;\n botToken: string;\n userToken?: string;\n authorizeResult: AuthorizeResult;\n} & PreAuthorizeSlackAppContext;",
"score": 0.8351397514343262
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n };\nexport type SlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {\n context: SlackAppContext;\n };\nexport type SlackRequest<\n E extends SlackAppEnv,\n Payload\n> = SlackMiddlwareRequest<E> & {",
"score": 0.8234255313873291
}
] |
typescript
|
SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize
|
?: Authorize<E>;
|
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/request/request.ts",
"retrieved_chunk": "import {\n SlackAppContext,\n PreAuthorizeSlackAppContext,\n SlackAppContextWithRespond,\n SlackAppContextWithOptionalRespond,\n SlackAppContextWithChannelId,\n} from \"../context/context\";\nimport { SlackAppEnv } from \"../app-env\";\nexport interface SlackMiddlewareRequestBase<E extends SlackAppEnv> {\n env: E;",
"score": 0.8801792860031128
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.8790294528007507
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": "import {\n InstallationError,\n MissingCode,\n CompletionPageError,\n InstallationStoreError,\n OpenIDConnectError,\n} from \"./oauth/error-codes\";\nexport interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {\n env: E;\n installationStore: InstallationStore<E>;",
"score": 0.8766948580741882
},
{
"filename": "src/authorization/authorize.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport { PreAuthorizeSlackMiddlwareRequest } from \"../request/request\";\nimport { AuthorizeResult } from \"./authorize-result\";\nexport type Authorize<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<AuthorizeResult>;",
"score": 0.8702359199523926
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8687544465065002
}
] |
typescript
|
?: Authorize<E>;
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
|
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
|
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/context/context.ts",
"retrieved_chunk": " // deno-lint-ignore no-explicit-any\n [key: string]: any; // custom properties\n };\n}\nexport type SlackAppContext = {\n client: SlackAPIClient;\n botToken: string;\n userToken?: string;\n authorizeResult: AuthorizeResult;\n} & PreAuthorizeSlackAppContext;",
"score": 0.8516207933425903
},
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": "import { PreAuthorizeMiddleware, Middleware } from \"./middleware\";\n// deno-lint-ignore require-await\nexport const urlVerification: PreAuthorizeMiddleware = async (req) => {\n if (req.body.type === \"url_verification\") {\n return { status: 200, body: req.body.challenge };\n }\n};\nconst eventTypesToKeep = [\"member_joined_channel\", \"member_left_channel\"];\n// deno-lint-ignore require-await\nexport const ignoringSelfEvents: Middleware = async (req) => {",
"score": 0.84653639793396
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.8342739343643188
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n // deno-lint-ignore no-explicit-any\n body: Record<string, any>;\n retryNum?: number;\n retryReason?: string;\n rawBody: string;\n headers: Headers;\n}\nexport type PreAuthorizeSlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {",
"score": 0.8314825892448425
},
{
"filename": "src/request/request-body.ts",
"retrieved_chunk": "export interface SlackRequestBody {\n type?: string;\n // slash commands\n command?: string;\n // event_callback\n event?: {\n type: string;\n subtype?: string;\n text?: string;\n };",
"score": 0.829768180847168
}
] |
typescript
|
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
|
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
|
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n}\nexport class SlackOAuthApp<E extends SlackOAuthEnv> extends SlackApp<E> {\n public env: E;\n public installationStore: InstallationStore<E>;\n public stateStore: StateStore;\n public oauth: {\n stateCookieName?: string;\n beforeInstallation?: BeforeInstallation;\n afterInstallation?: AfterInstallation;",
"score": 0.8998105525970459
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.89000403881073
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8892651200294495
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": "import {\n SlackAppContext,\n PreAuthorizeSlackAppContext,\n SlackAppContextWithRespond,\n SlackAppContextWithOptionalRespond,\n SlackAppContextWithChannelId,\n} from \"../context/context\";\nimport { SlackAppEnv } from \"../app-env\";\nexport interface SlackMiddlewareRequestBase<E extends SlackAppEnv> {\n env: E;",
"score": 0.8792892694473267
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": "import {\n InstallationError,\n MissingCode,\n CompletionPageError,\n InstallationStoreError,\n OpenIDConnectError,\n} from \"./oauth/error-codes\";\nexport interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {\n env: E;\n installationStore: InstallationStore<E>;",
"score": 0.8616267442703247
}
] |
typescript
|
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
|
public socketModeClient: SocketModeClient | undefined;
|
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.9140313863754272
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n}\nexport class SlackOAuthApp<E extends SlackOAuthEnv> extends SlackApp<E> {\n public env: E;\n public installationStore: InstallationStore<E>;\n public stateStore: StateStore;\n public oauth: {\n stateCookieName?: string;\n beforeInstallation?: BeforeInstallation;\n afterInstallation?: AfterInstallation;",
"score": 0.9077798128128052
},
{
"filename": "src/socket-mode/socket-mode-client.ts",
"retrieved_chunk": "import { SlackAPIClient, isDebugLogEnabled } from \"slack-web-api-client\";\nimport { SlackApp } from \"../app\";\nimport { ConfigError, SocketModeError } from \"../errors\";\nimport { ExecutionContext } from \"../execution-context\";\nimport { SlackSocketModeAppEnv } from \"../app-env\";\n// TODO: Implement proper reconnection logic\n// TODO: Add connection monitor like 1st party SDKs do\n// TODO: Add Bun support (the runtime does not work well with Socket Mode)\nexport class SocketModeClient {\n public app: SlackApp<SlackSocketModeAppEnv>;",
"score": 0.8931312561035156
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8903559446334839
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": "export interface SlackLoggingLevel {\n SLACK_LOGGING_LEVEL?: \"DEBUG\" | \"INFO\" | \"WARN\" | \"ERROR\";\n}\nexport type SlackAppEnv = SlackLoggingLevel & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN?: string;\n};\nexport type SlackEdgeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET: string;",
"score": 0.8819853067398071
}
] |
typescript
|
public socketModeClient: SocketModeClient | undefined;
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
|
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
|
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": "import { PreAuthorizeMiddleware, Middleware } from \"./middleware\";\n// deno-lint-ignore require-await\nexport const urlVerification: PreAuthorizeMiddleware = async (req) => {\n if (req.body.type === \"url_verification\") {\n return { status: 200, body: req.body.challenge };\n }\n};\nconst eventTypesToKeep = [\"member_joined_channel\", \"member_left_channel\"];\n// deno-lint-ignore require-await\nexport const ignoringSelfEvents: Middleware = async (req) => {",
"score": 0.8374695777893066
},
{
"filename": "src/middleware/middleware.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport {\n PreAuthorizeSlackMiddlwareRequest,\n SlackMiddlwareRequest,\n} from \"../request/request\";\nimport { SlackResponse } from \"../response/response\";\nexport type PreAuthorizeMiddleware<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<SlackResponse | void>;\nexport type Middleware<E extends SlackAppEnv = SlackAppEnv> = (",
"score": 0.8331334590911865
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n // deno-lint-ignore no-explicit-any\n body: Record<string, any>;\n retryNum?: number;\n retryReason?: string;\n rawBody: string;\n headers: Headers;\n}\nexport type PreAuthorizeSlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {",
"score": 0.8310006260871887
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n };\nexport type SlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {\n context: SlackAppContext;\n };\nexport type SlackRequest<\n E extends SlackAppEnv,\n Payload\n> = SlackMiddlwareRequest<E> & {",
"score": 0.8243683576583862
},
{
"filename": "src/request/request-body.ts",
"retrieved_chunk": "export interface SlackRequestBody {\n type?: string;\n // slash commands\n command?: string;\n // event_callback\n event?: {\n type: string;\n subtype?: string;\n text?: string;\n };",
"score": 0.8232412338256836
}
] |
typescript
|
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware
|
: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
|
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": "import { PreAuthorizeMiddleware, Middleware } from \"./middleware\";\n// deno-lint-ignore require-await\nexport const urlVerification: PreAuthorizeMiddleware = async (req) => {\n if (req.body.type === \"url_verification\") {\n return { status: 200, body: req.body.challenge };\n }\n};\nconst eventTypesToKeep = [\"member_joined_channel\", \"member_left_channel\"];\n// deno-lint-ignore require-await\nexport const ignoringSelfEvents: Middleware = async (req) => {",
"score": 0.8702839016914368
},
{
"filename": "src/context/context.ts",
"retrieved_chunk": " // deno-lint-ignore no-explicit-any\n [key: string]: any; // custom properties\n };\n}\nexport type SlackAppContext = {\n client: SlackAPIClient;\n botToken: string;\n userToken?: string;\n authorizeResult: AuthorizeResult;\n} & PreAuthorizeSlackAppContext;",
"score": 0.8421934247016907
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " stateCookieName?: string;\n callback: OpenIDConnectCallback;\n onFailure?: OnFailure;\n onStateValidationError?: OnStateValidationError;\n redirectUri?: string;\n };\n routes?: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };",
"score": 0.8402445912361145
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8248006701469421
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n // deno-lint-ignore no-explicit-any\n body: Record<string, any>;\n retryNum?: number;\n retryReason?: string;\n rawBody: string;\n headers: Headers;\n}\nexport type PreAuthorizeSlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {",
"score": 0.82431960105896
}
] |
typescript
|
: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
|
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
|
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.8666974306106567
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": "import {\n SlackAppContext,\n PreAuthorizeSlackAppContext,\n SlackAppContextWithRespond,\n SlackAppContextWithOptionalRespond,\n SlackAppContextWithChannelId,\n} from \"../context/context\";\nimport { SlackAppEnv } from \"../app-env\";\nexport interface SlackMiddlewareRequestBase<E extends SlackAppEnv> {\n env: E;",
"score": 0.8628866672515869
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": "import {\n InstallationError,\n MissingCode,\n CompletionPageError,\n InstallationStoreError,\n OpenIDConnectError,\n} from \"./oauth/error-codes\";\nexport interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {\n env: E;\n installationStore: InstallationStore<E>;",
"score": 0.8600023984909058
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n };\nexport type SlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {\n context: SlackAppContext;\n };\nexport type SlackRequest<\n E extends SlackAppEnv,\n Payload\n> = SlackMiddlwareRequest<E> & {",
"score": 0.8563731908798218
},
{
"filename": "src/socket-mode/socket-mode-client.ts",
"retrieved_chunk": "import { SlackAPIClient, isDebugLogEnabled } from \"slack-web-api-client\";\nimport { SlackApp } from \"../app\";\nimport { ConfigError, SocketModeError } from \"../errors\";\nimport { ExecutionContext } from \"../execution-context\";\nimport { SlackSocketModeAppEnv } from \"../app-env\";\n// TODO: Implement proper reconnection logic\n// TODO: Add connection monitor like 1st party SDKs do\n// TODO: Add Bun support (the runtime does not work well with Socket Mode)\nexport class SocketModeClient {\n public app: SlackApp<SlackSocketModeAppEnv>;",
"score": 0.8557829260826111
}
] |
typescript
|
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
|
options.authorize === singleTeamAuthorize)
) {
|
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8443302512168884
},
{
"filename": "src/response/response.ts",
"retrieved_chunk": "}\nexport type SlackViewResponse =\n | (SlackResponse & {\n body: \"\" | AnyViewResponse;\n })\n | \"\"\n | AnyViewResponse\n | undefined\n | void;\nexport type SlackOptionsResponse =",
"score": 0.8349260091781616
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " routes: { events: options.routes?.events ?? \"/slack/events\" },\n });\n this.env = options.env;\n this.installationStore = options.installationStore;\n this.stateStore = options.stateStore ?? new NoStorageStateStore();\n this.oauth = {\n stateCookieName:\n options.oauth?.stateCookieName ?? \"slack-app-oauth-state\",\n onFailure: options.oauth?.onFailure ?? defaultOnFailure,\n onStateValidationError:",
"score": 0.8288490176200867
},
{
"filename": "src/request/payload/view-closed.ts",
"retrieved_chunk": "import { DataSubmissionView } from \"./view-objects\";\nexport interface ViewClosed {\n type: \"view_closed\";\n team: {\n id: string;\n domain: string;\n enterprise_id?: string;\n enterprise_name?: string;\n } | null;\n user: {",
"score": 0.81914222240448
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " redirectUri:\n options.oidc.redirectUri ?? this.env.SLACK_OIDC_REDIRECT_URI,\n };\n } else {\n this.oidc = undefined;\n }\n this.routes = options.routes\n ? options.routes\n : {\n events: \"/slack/events\",",
"score": 0.8188334107398987
}
] |
typescript
|
options.authorize === singleTeamAuthorize)
) {
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends
|
SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
|
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.8638103604316711
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": "import {\n SlackAppContext,\n PreAuthorizeSlackAppContext,\n SlackAppContextWithRespond,\n SlackAppContextWithOptionalRespond,\n SlackAppContextWithChannelId,\n} from \"../context/context\";\nimport { SlackAppEnv } from \"../app-env\";\nexport interface SlackMiddlewareRequestBase<E extends SlackAppEnv> {\n env: E;",
"score": 0.8600237965583801
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": "import {\n InstallationError,\n MissingCode,\n CompletionPageError,\n InstallationStoreError,\n OpenIDConnectError,\n} from \"./oauth/error-codes\";\nexport interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {\n env: E;\n installationStore: InstallationStore<E>;",
"score": 0.8553712964057922
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n };\nexport type SlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {\n context: SlackAppContext;\n };\nexport type SlackRequest<\n E extends SlackAppEnv,\n Payload\n> = SlackMiddlwareRequest<E> & {",
"score": 0.8543167114257812
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8515267968177795
}
] |
typescript
|
SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) =>
|
SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
|
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/request/request-body.ts",
"retrieved_chunk": " // shortcut, message_action\n callback_id?: string;\n // block_actions\n actions: {\n type: string;\n block_id: string;\n action_id: string;\n }[];\n // block_suggestion\n block_id?: string;",
"score": 0.836223840713501
},
{
"filename": "src/request/request-body.ts",
"retrieved_chunk": "export interface SlackRequestBody {\n type?: string;\n // slash commands\n command?: string;\n // event_callback\n event?: {\n type: string;\n subtype?: string;\n text?: string;\n };",
"score": 0.8232455253601074
},
{
"filename": "src/request/payload/view-objects.ts",
"retrieved_chunk": " type: AnyActionBlockElementType;\n value?: string | null;\n selected_date?: string | null;\n selected_time?: string | null;\n selected_date_time?: number | null;\n selected_conversation?: string | null;\n selected_channel?: string | null;\n selected_user?: string | null;\n selected_option?: ViewStateSelectedOption | null;\n selected_conversations?: string[];",
"score": 0.8188844919204712
},
{
"filename": "src/request/payload/block-action.ts",
"retrieved_chunk": " extends BlockElementAction<\"multi_users_select\"> {\n selected_users: string[];\n initial_users?: string[];\n placeholder?: PlainTextField;\n confirm?: Confirm;\n}\nexport interface ConversationsSelectAction\n extends BlockElementAction<\"conversations_select\"> {\n selected_conversation: string;\n initial_conversation?: string;",
"score": 0.8160418272018433
},
{
"filename": "src/response/response.ts",
"retrieved_chunk": "import {\n MessageResponse,\n AnyOptionsResponse,\n AnyViewResponse,\n} from \"./response-body\";\nexport interface SlackResponse {\n status?: number;\n contentType?: string;\n // deno-lint-ignore no-explicit-any\n body?: string | MessageResponse | Record<string, any>;",
"score": 0.8123759031295776
}
] |
typescript
|
SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
|
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
|
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": "import { PreAuthorizeMiddleware, Middleware } from \"./middleware\";\n// deno-lint-ignore require-await\nexport const urlVerification: PreAuthorizeMiddleware = async (req) => {\n if (req.body.type === \"url_verification\") {\n return { status: 200, body: req.body.challenge };\n }\n};\nconst eventTypesToKeep = [\"member_joined_channel\", \"member_left_channel\"];\n// deno-lint-ignore require-await\nexport const ignoringSelfEvents: Middleware = async (req) => {",
"score": 0.8596798777580261
},
{
"filename": "src/context/context.ts",
"retrieved_chunk": " // deno-lint-ignore no-explicit-any\n [key: string]: any; // custom properties\n };\n}\nexport type SlackAppContext = {\n client: SlackAPIClient;\n botToken: string;\n userToken?: string;\n authorizeResult: AuthorizeResult;\n} & PreAuthorizeSlackAppContext;",
"score": 0.8525781631469727
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8423880934715271
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n // deno-lint-ignore no-explicit-any\n body: Record<string, any>;\n retryNum?: number;\n retryReason?: string;\n rawBody: string;\n headers: Headers;\n}\nexport type PreAuthorizeSlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {",
"score": 0.8369297981262207
},
{
"filename": "src/authorization/authorize.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport { PreAuthorizeSlackMiddlwareRequest } from \"../request/request\";\nimport { AuthorizeResult } from \"./authorize-result\";\nexport type Authorize<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<AuthorizeResult>;",
"score": 0.8348995447158813
}
] |
typescript
|
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
)
|
=> SlackViewHandler<E, ViewSubmission> | null)[] = [];
|
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/request/payload/block-suggestion.ts",
"retrieved_chunk": "import { AnyOption } from \"slack-web-api-client\";\nimport { DataSubmissionView } from \"./view-objects\";\nexport interface BlockSuggestion {\n type: \"block_suggestion\";\n block_id: string;\n action_id: string;\n value: string;\n api_app_id: string;\n team: {\n id: string;",
"score": 0.8418246507644653
},
{
"filename": "src/request/request-body.ts",
"retrieved_chunk": " // shortcut, message_action\n callback_id?: string;\n // block_actions\n actions: {\n type: string;\n block_id: string;\n action_id: string;\n }[];\n // block_suggestion\n block_id?: string;",
"score": 0.8349205255508423
},
{
"filename": "src/request/payload/block-action.ts",
"retrieved_chunk": "import { Confirm, AnyOption, PlainTextField } from \"slack-web-api-client\";\nimport { DataSubmissionView, ViewStateValue } from \"./view-objects\";\nexport interface BlockAction<A extends BlockElementAction> {\n type: \"block_actions\";\n actions: A[];\n team: {\n id: string;\n domain: string;\n enterprise_id?: string;\n enterprise_name?: string;",
"score": 0.8269398212432861
},
{
"filename": "src/request/payload/view-objects.ts",
"retrieved_chunk": " type: AnyActionBlockElementType;\n value?: string | null;\n selected_date?: string | null;\n selected_time?: string | null;\n selected_date_time?: number | null;\n selected_conversation?: string | null;\n selected_channel?: string | null;\n selected_user?: string | null;\n selected_option?: ViewStateSelectedOption | null;\n selected_conversations?: string[];",
"score": 0.8249472975730896
},
{
"filename": "src/response/response.ts",
"retrieved_chunk": "}\nexport type SlackViewResponse =\n | (SlackResponse & {\n body: \"\" | AnyViewResponse;\n })\n | \"\"\n | AnyViewResponse\n | undefined\n | void;\nexport type SlackOptionsResponse =",
"score": 0.8248183727264404
}
] |
typescript
|
=> SlackViewHandler<E, ViewSubmission> | null)[] = [];
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
|
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
|
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8443030118942261
},
{
"filename": "src/response/response.ts",
"retrieved_chunk": "}\nexport type SlackViewResponse =\n | (SlackResponse & {\n body: \"\" | AnyViewResponse;\n })\n | \"\"\n | AnyViewResponse\n | undefined\n | void;\nexport type SlackOptionsResponse =",
"score": 0.8348890542984009
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " routes: { events: options.routes?.events ?? \"/slack/events\" },\n });\n this.env = options.env;\n this.installationStore = options.installationStore;\n this.stateStore = options.stateStore ?? new NoStorageStateStore();\n this.oauth = {\n stateCookieName:\n options.oauth?.stateCookieName ?? \"slack-app-oauth-state\",\n onFailure: options.oauth?.onFailure ?? defaultOnFailure,\n onStateValidationError:",
"score": 0.8287662267684937
},
{
"filename": "src/request/payload/view-closed.ts",
"retrieved_chunk": "import { DataSubmissionView } from \"./view-objects\";\nexport interface ViewClosed {\n type: \"view_closed\";\n team: {\n id: string;\n domain: string;\n enterprise_id?: string;\n enterprise_name?: string;\n } | null;\n user: {",
"score": 0.8192648887634277
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " redirectUri:\n options.oidc.redirectUri ?? this.env.SLACK_OIDC_REDIRECT_URI,\n };\n } else {\n this.oidc = undefined;\n }\n this.routes = options.routes\n ? options.routes\n : {\n events: \"/slack/events\",",
"score": 0.8186912536621094
}
] |
typescript
|
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
)
|
=> SlackMessageHandler<E, SlashCommand> | null)[] = [];
|
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": "import { PreAuthorizeMiddleware, Middleware } from \"./middleware\";\n// deno-lint-ignore require-await\nexport const urlVerification: PreAuthorizeMiddleware = async (req) => {\n if (req.body.type === \"url_verification\") {\n return { status: 200, body: req.body.challenge };\n }\n};\nconst eventTypesToKeep = [\"member_joined_channel\", \"member_left_channel\"];\n// deno-lint-ignore require-await\nexport const ignoringSelfEvents: Middleware = async (req) => {",
"score": 0.8809192776679993
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n // deno-lint-ignore no-explicit-any\n body: Record<string, any>;\n retryNum?: number;\n retryReason?: string;\n rawBody: string;\n headers: Headers;\n}\nexport type PreAuthorizeSlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {",
"score": 0.8409168124198914
},
{
"filename": "src/middleware/middleware.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport {\n PreAuthorizeSlackMiddlwareRequest,\n SlackMiddlwareRequest,\n} from \"../request/request\";\nimport { SlackResponse } from \"../response/response\";\nexport type PreAuthorizeMiddleware<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<SlackResponse | void>;\nexport type Middleware<E extends SlackAppEnv = SlackAppEnv> = (",
"score": 0.838944673538208
},
{
"filename": "src/context/context.ts",
"retrieved_chunk": " // deno-lint-ignore no-explicit-any\n [key: string]: any; // custom properties\n };\n}\nexport type SlackAppContext = {\n client: SlackAPIClient;\n botToken: string;\n userToken?: string;\n authorizeResult: AuthorizeResult;\n} & PreAuthorizeSlackAppContext;",
"score": 0.8343872427940369
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n };\nexport type SlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {\n context: SlackAppContext;\n };\nexport type SlackRequest<\n E extends SlackAppEnv,\n Payload\n> = SlackMiddlwareRequest<E> & {",
"score": 0.8221344947814941
}
] |
typescript
|
=> SlackMessageHandler<E, SlashCommand> | null)[] = [];
|
import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { Allowed } from './allowed.entity';
import { IAllowedLeaves, ILeaveApplication } from './leave.dto';
import { Leave } from './leave.entity';
@Injectable()
export class LeaveService {
async allowedLeaves(data: IAllowedLeaves) {
//to get the value between these three
if (
data.leaveType !== 'earnedLeaves' &&
data.leaveType !== 'casualLeaves' &&
data.leaveType !== 'compensatoryLeaves'
) {
throw new HttpException(
'you must enter the type of leave between casualLeaves , compensatoryLeaves & earnedLeaves',
HttpStatus.BAD_REQUEST,
);
}
const application = new Allowed();
application.leaveType = data.leaveType;
application.allowedLeaves = data.allowedLeaves;
application.remainingLeaves = data.allowedLeaves;
await application.save();
return application;
}
async Leaves() {
const allowedLeavesData = await Allowed.find();
return allowedLeavesData;
}
async application(data: ILeaveApplication) {
// to get number of days
let test = data.toDate.toString().split('T'); //T replace
let test2 = test[0].toString().split('-');
let date1 = test2[2];
let test3 = data.fromDate.toString().split('T'); //T replace
let test4 = test3[0].toString().split('-');
let date2 = test4[2];
let diff = parseInt(date2) - parseInt(date1) + 1;
//updating consumed leaves
if (data.descriptionLeave == 'Casual') {
const Leavesdata = await Allowed.findOneBy({ leaveType: 'casualLeaves' });
//to check remaining leaves is not zero
if (Leavesdata.remainingLeaves - diff < 0) {
throw new HttpException(
'Maximum leaves consumed!', HttpStatus.BAD_REQUEST
);
}
//updating data
Leavesdata.consumedLeaves += diff;
Leavesdata.remainingLeaves =
Leavesdata.allowedLeaves - Leavesdata.consumedLeaves;
await Leavesdata.save();
} else if (data.descriptionLeave == 'Compensatory') {
const Leavesdata = await Allowed.findOneBy({
leaveType: 'compensatoryLeaves',
});
//to check remaining leaves is not zero
if (Leavesdata.remainingLeaves - diff < 0) {
throw new HttpException(
'Maximum leaves consumed!', HttpStatus.BAD_REQUEST,
);
}
//updating data
Leavesdata.consumedLeaves += diff;
Leavesdata.remainingLeaves =
Leavesdata.allowedLeaves - Leavesdata.consumedLeaves;
await Leavesdata.save();
} else {
const Leavesdata = await Allowed.findOneBy({ leaveType: 'earnedLeaves' });
//to check remaining leaves is not zero
if (Leavesdata.remainingLeaves - diff < 0) {
throw new HttpException(
'Maximum leaves consumed!', HttpStatus.BAD_REQUEST,
);
}
//updating data
Leavesdata.consumedLeaves += diff;
Leavesdata.remainingLeaves =
Leavesdata.allowedLeaves - Leavesdata.consumedLeaves;
await Leavesdata.save();
}
//creation of new application
|
const leave = new Leave();
|
leave.toDate = data.toDate;
leave.fromDate = data.fromDate;
leave.leaveType = data.leaveType;
leave.descriptionLeave = data.descriptionLeave;
leave.reason = data.reason;
await leave.save();
const allowedLeavesData = await Allowed.find();
return {
...leave,
leaveinfo: allowedLeavesData,
};
}
}
|
src/leave/leave.service.ts
|
SaadKhawaja01-leave-chunk-8cdb4ca
|
[
{
"filename": "src/leave/leave.controller.ts",
"retrieved_chunk": " async allowedLeaves(@Body() data: AllowedLeaves) {\n return await this.leaveService.allowedLeaves(data);\n }\n @Get()\n async Leaves() {\n return await this.leaveService.Leaves();\n }\n @Post('/application')\n async application(@Body() data: LeaveApplication) {\n return await this.leaveService.application(data);",
"score": 0.8487883806228638
},
{
"filename": "src/leave/allowed.entity.ts",
"retrieved_chunk": " consumedLeaves: number;\n @Column()\n remainingLeaves: number;\n}",
"score": 0.8335395455360413
},
{
"filename": "src/leave/leave.controller.ts",
"retrieved_chunk": "import { Body, Controller, Post} from '@nestjs/common';\nimport { Get } from '@nestjs/common/decorators';\nimport { ApiTags } from '@nestjs/swagger';\nimport { AllowedLeaves, LeaveApplication } from './leave.model';\nimport { LeaveService } from './leave.service';\n@ApiTags('Leave')\n@Controller('leave')\nexport class LeaveController {\n constructor(private readonly leaveService: LeaveService) {}\n @Post('/allowedLeaves')",
"score": 0.8230900764465332
},
{
"filename": "src/leave/leave.dto.ts",
"retrieved_chunk": "export interface ILeaveApplication {\n toDate: Date;\n fromDate: Date;\n leaveType: string;\n descriptionLeave: string;\n reason: string;\n}\nexport interface IAllowedLeaves {\n leaveType: string;\n allowedLeaves: number;",
"score": 0.8082035779953003
},
{
"filename": "src/leave/leave.model.ts",
"retrieved_chunk": "import { ApiProperty } from '@nestjs/swagger';\nimport {\n IsDate,\n IsNotEmpty,\n IsNumber,\n IsString\n} from 'class-validator';\nimport { IAllowedLeaves, ILeaveApplication } from './leave.dto';\nexport class LeaveApplication implements ILeaveApplication {\n @ApiProperty()",
"score": 0.8055965900421143
}
] |
typescript
|
const leave = new Leave();
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware:
|
PreAuthorizeMiddleware<E>): SlackApp<E> {
|
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8872484564781189
},
{
"filename": "src/middleware/middleware.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport {\n PreAuthorizeSlackMiddlwareRequest,\n SlackMiddlwareRequest,\n} from \"../request/request\";\nimport { SlackResponse } from \"../response/response\";\nexport type PreAuthorizeMiddleware<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<SlackResponse | void>;\nexport type Middleware<E extends SlackAppEnv = SlackAppEnv> = (",
"score": 0.862578272819519
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " routes: { events: options.routes?.events ?? \"/slack/events\" },\n });\n this.env = options.env;\n this.installationStore = options.installationStore;\n this.stateStore = options.stateStore ?? new NoStorageStateStore();\n this.oauth = {\n stateCookieName:\n options.oauth?.stateCookieName ?? \"slack-app-oauth-state\",\n onFailure: options.oauth?.onFailure ?? defaultOnFailure,\n onStateValidationError:",
"score": 0.8612654209136963
},
{
"filename": "src/authorization/authorize.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport { PreAuthorizeSlackMiddlwareRequest } from \"../request/request\";\nimport { AuthorizeResult } from \"./authorize-result\";\nexport type Authorize<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<AuthorizeResult>;",
"score": 0.8577573299407959
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": "import {\n SlackAppContext,\n PreAuthorizeSlackAppContext,\n SlackAppContextWithRespond,\n SlackAppContextWithOptionalRespond,\n SlackAppContextWithChannelId,\n} from \"../context/context\";\nimport { SlackAppEnv } from \"../app-env\";\nexport interface SlackMiddlewareRequestBase<E extends SlackAppEnv> {\n env: E;",
"score": 0.8435304164886475
}
] |
typescript
|
PreAuthorizeMiddleware<E>): SlackApp<E> {
|
import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { Allowed } from './allowed.entity';
import { IAllowedLeaves, ILeaveApplication } from './leave.dto';
import { Leave } from './leave.entity';
@Injectable()
export class LeaveService {
async allowedLeaves(data: IAllowedLeaves) {
//to get the value between these three
if (
data.leaveType !== 'earnedLeaves' &&
data.leaveType !== 'casualLeaves' &&
data.leaveType !== 'compensatoryLeaves'
) {
throw new HttpException(
'you must enter the type of leave between casualLeaves , compensatoryLeaves & earnedLeaves',
HttpStatus.BAD_REQUEST,
);
}
const application = new Allowed();
application.leaveType = data.leaveType;
application.allowedLeaves = data.allowedLeaves;
application.remainingLeaves = data.allowedLeaves;
await application.save();
return application;
}
async Leaves() {
const allowedLeavesData = await Allowed.find();
return allowedLeavesData;
}
async application(data: ILeaveApplication) {
// to get number of days
let test = data.toDate.toString().split('T'); //T replace
let test2 = test[0].toString().split('-');
let date1 = test2[2];
let test3 = data.fromDate.toString().split('T'); //T replace
let test4 = test3[0].toString().split('-');
let date2 = test4[2];
let diff = parseInt(date2) - parseInt(date1) + 1;
//updating consumed leaves
if (data.descriptionLeave == 'Casual') {
const Leavesdata = await Allowed.findOneBy({ leaveType: 'casualLeaves' });
//to check remaining leaves is not zero
if (Leavesdata.remainingLeaves - diff < 0) {
throw new HttpException(
'Maximum leaves consumed!', HttpStatus.BAD_REQUEST
);
}
//updating data
Leavesdata.consumedLeaves += diff;
Leavesdata.remainingLeaves =
Leavesdata.allowedLeaves - Leavesdata.consumedLeaves;
await Leavesdata.save();
} else if (data.descriptionLeave == 'Compensatory') {
const Leavesdata = await Allowed.findOneBy({
leaveType: 'compensatoryLeaves',
});
//to check remaining leaves is not zero
if (Leavesdata.remainingLeaves - diff < 0) {
throw new HttpException(
'Maximum leaves consumed!', HttpStatus.BAD_REQUEST,
);
}
//updating data
Leavesdata.consumedLeaves += diff;
Leavesdata.remainingLeaves =
Leavesdata.allowedLeaves - Leavesdata.consumedLeaves;
await Leavesdata.save();
} else {
const Leavesdata = await Allowed.findOneBy({ leaveType: 'earnedLeaves' });
//to check remaining leaves is not zero
if (Leavesdata.remainingLeaves - diff < 0) {
throw new HttpException(
'Maximum leaves consumed!', HttpStatus.BAD_REQUEST,
);
}
//updating data
Leavesdata.consumedLeaves += diff;
Leavesdata.remainingLeaves =
Leavesdata.allowedLeaves - Leavesdata.consumedLeaves;
await Leavesdata.save();
}
//creation of new application
const leave = new Leave();
leave.toDate = data.toDate;
leave.fromDate = data.fromDate;
|
leave.leaveType = data.leaveType;
|
leave.descriptionLeave = data.descriptionLeave;
leave.reason = data.reason;
await leave.save();
const allowedLeavesData = await Allowed.find();
return {
...leave,
leaveinfo: allowedLeavesData,
};
}
}
|
src/leave/leave.service.ts
|
SaadKhawaja01-leave-chunk-8cdb4ca
|
[
{
"filename": "src/leave/leave.controller.ts",
"retrieved_chunk": " async allowedLeaves(@Body() data: AllowedLeaves) {\n return await this.leaveService.allowedLeaves(data);\n }\n @Get()\n async Leaves() {\n return await this.leaveService.Leaves();\n }\n @Post('/application')\n async application(@Body() data: LeaveApplication) {\n return await this.leaveService.application(data);",
"score": 0.8486447930335999
},
{
"filename": "src/leave/allowed.entity.ts",
"retrieved_chunk": " consumedLeaves: number;\n @Column()\n remainingLeaves: number;\n}",
"score": 0.8249832391738892
},
{
"filename": "src/leave/leave.dto.ts",
"retrieved_chunk": "export interface ILeaveApplication {\n toDate: Date;\n fromDate: Date;\n leaveType: string;\n descriptionLeave: string;\n reason: string;\n}\nexport interface IAllowedLeaves {\n leaveType: string;\n allowedLeaves: number;",
"score": 0.8172745704650879
},
{
"filename": "src/leave/leave.dto.ts",
"retrieved_chunk": "}\nexport interface ILeaveApplicationResponse {\n id: string;\n employeeId: string;\n applcationDate: Date;\n allowedLeaves: number;\n consumedLeaves: number;\n availableLeaves: number;\n description: string;\n leaveDates: string;",
"score": 0.8091511726379395
},
{
"filename": "src/leave/leave.controller.ts",
"retrieved_chunk": "import { Body, Controller, Post} from '@nestjs/common';\nimport { Get } from '@nestjs/common/decorators';\nimport { ApiTags } from '@nestjs/swagger';\nimport { AllowedLeaves, LeaveApplication } from './leave.model';\nimport { LeaveService } from './leave.service';\n@ApiTags('Leave')\n@Controller('leave')\nexport class LeaveController {\n constructor(private readonly leaveService: LeaveService) {}\n @Post('/allowedLeaves')",
"score": 0.8075374364852905
}
] |
typescript
|
leave.leaveType = data.leaveType;
|
import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { Allowed } from './allowed.entity';
import { IAllowedLeaves, ILeaveApplication } from './leave.dto';
import { Leave } from './leave.entity';
@Injectable()
export class LeaveService {
async allowedLeaves(data: IAllowedLeaves) {
//to get the value between these three
if (
data.leaveType !== 'earnedLeaves' &&
data.leaveType !== 'casualLeaves' &&
data.leaveType !== 'compensatoryLeaves'
) {
throw new HttpException(
'you must enter the type of leave between casualLeaves , compensatoryLeaves & earnedLeaves',
HttpStatus.BAD_REQUEST,
);
}
const application = new Allowed();
application.leaveType = data.leaveType;
application.allowedLeaves = data.allowedLeaves;
application.remainingLeaves = data.allowedLeaves;
await application.save();
return application;
}
async Leaves() {
const allowedLeavesData = await Allowed.find();
return allowedLeavesData;
}
async application(data: ILeaveApplication) {
// to get number of days
let test = data.toDate.toString().split('T'); //T replace
let test2 = test[0].toString().split('-');
let date1 = test2[2];
let test3 = data.fromDate.toString().split('T'); //T replace
let test4 = test3[0].toString().split('-');
let date2 = test4[2];
let diff = parseInt(date2) - parseInt(date1) + 1;
//updating consumed leaves
if (data.descriptionLeave == 'Casual') {
const Leavesdata = await
|
Allowed.findOneBy({ leaveType: 'casualLeaves' });
|
//to check remaining leaves is not zero
if (Leavesdata.remainingLeaves - diff < 0) {
throw new HttpException(
'Maximum leaves consumed!', HttpStatus.BAD_REQUEST
);
}
//updating data
Leavesdata.consumedLeaves += diff;
Leavesdata.remainingLeaves =
Leavesdata.allowedLeaves - Leavesdata.consumedLeaves;
await Leavesdata.save();
} else if (data.descriptionLeave == 'Compensatory') {
const Leavesdata = await Allowed.findOneBy({
leaveType: 'compensatoryLeaves',
});
//to check remaining leaves is not zero
if (Leavesdata.remainingLeaves - diff < 0) {
throw new HttpException(
'Maximum leaves consumed!', HttpStatus.BAD_REQUEST,
);
}
//updating data
Leavesdata.consumedLeaves += diff;
Leavesdata.remainingLeaves =
Leavesdata.allowedLeaves - Leavesdata.consumedLeaves;
await Leavesdata.save();
} else {
const Leavesdata = await Allowed.findOneBy({ leaveType: 'earnedLeaves' });
//to check remaining leaves is not zero
if (Leavesdata.remainingLeaves - diff < 0) {
throw new HttpException(
'Maximum leaves consumed!', HttpStatus.BAD_REQUEST,
);
}
//updating data
Leavesdata.consumedLeaves += diff;
Leavesdata.remainingLeaves =
Leavesdata.allowedLeaves - Leavesdata.consumedLeaves;
await Leavesdata.save();
}
//creation of new application
const leave = new Leave();
leave.toDate = data.toDate;
leave.fromDate = data.fromDate;
leave.leaveType = data.leaveType;
leave.descriptionLeave = data.descriptionLeave;
leave.reason = data.reason;
await leave.save();
const allowedLeavesData = await Allowed.find();
return {
...leave,
leaveinfo: allowedLeavesData,
};
}
}
|
src/leave/leave.service.ts
|
SaadKhawaja01-leave-chunk-8cdb4ca
|
[
{
"filename": "src/leave/leave.controller.ts",
"retrieved_chunk": " async allowedLeaves(@Body() data: AllowedLeaves) {\n return await this.leaveService.allowedLeaves(data);\n }\n @Get()\n async Leaves() {\n return await this.leaveService.Leaves();\n }\n @Post('/application')\n async application(@Body() data: LeaveApplication) {\n return await this.leaveService.application(data);",
"score": 0.7788488864898682
},
{
"filename": "src/leave/leave.dto.ts",
"retrieved_chunk": "export interface ILeaveApplication {\n toDate: Date;\n fromDate: Date;\n leaveType: string;\n descriptionLeave: string;\n reason: string;\n}\nexport interface IAllowedLeaves {\n leaveType: string;\n allowedLeaves: number;",
"score": 0.7783854007720947
},
{
"filename": "src/leave/allowed.entity.ts",
"retrieved_chunk": " consumedLeaves: number;\n @Column()\n remainingLeaves: number;\n}",
"score": 0.7758575677871704
},
{
"filename": "src/leave/leave.dto.ts",
"retrieved_chunk": "}\nexport interface ILeaveApplicationResponse {\n id: string;\n employeeId: string;\n applcationDate: Date;\n allowedLeaves: number;\n consumedLeaves: number;\n availableLeaves: number;\n description: string;\n leaveDates: string;",
"score": 0.7633633613586426
},
{
"filename": "src/leave/leave.model.ts",
"retrieved_chunk": "export class AllowedLeaves implements IAllowedLeaves {\n @ApiProperty()\n @IsNotEmpty()\n @IsString()\n leaveType: string;\n @ApiProperty()\n @IsNotEmpty()\n @IsNumber()\n allowedLeaves: number;\n}",
"score": 0.7539249658584595
}
] |
typescript
|
Allowed.findOneBy({ leaveType: 'casualLeaves' });
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new
|
ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
|
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8772692680358887
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " routes: { events: options.routes?.events ?? \"/slack/events\" },\n });\n this.env = options.env;\n this.installationStore = options.installationStore;\n this.stateStore = options.stateStore ?? new NoStorageStateStore();\n this.oauth = {\n stateCookieName:\n options.oauth?.stateCookieName ?? \"slack-app-oauth-state\",\n onFailure: options.oauth?.onFailure ?? defaultOnFailure,\n onStateValidationError:",
"score": 0.848176121711731
},
{
"filename": "src/authorization/single-team-authorize.ts",
"retrieved_chunk": "import { AuthorizeError } from \"../errors\";\nimport {\n SlackAPIClient,\n AuthTestResponse,\n SlackAPIError,\n} from \"slack-web-api-client\";\nimport { Authorize } from \"./authorize\";\nexport const singleTeamAuthorize: Authorize = async (req) => {\n // This authorize function supports only the bot token for a workspace\n const botToken = req.env.SLACK_BOT_TOKEN!;",
"score": 0.8414891362190247
},
{
"filename": "src/socket-mode/socket-mode-client.ts",
"retrieved_chunk": " public appLevelToken: string;\n public ws: WebSocket | undefined;\n constructor(\n // deno-lint-ignore no-explicit-any\n app: SlackApp<any>\n ) {\n if (!app.socketMode) {\n throw new ConfigError(\n \"socketMode: true must be set for running with Socket Mode\"\n );",
"score": 0.8344168066978455
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": "import {\n InstallationError,\n MissingCode,\n CompletionPageError,\n InstallationStoreError,\n OpenIDConnectError,\n} from \"./oauth/error-codes\";\nexport interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {\n env: E;\n installationStore: InstallationStore<E>;",
"score": 0.8322511911392212
}
] |
typescript
|
ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
|
if (body.type !== PayloadType.EventsAPI || !body.event) {
|
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/request/payload/event.ts",
"retrieved_chunk": " | SharedChannelInviteApprovedEvent\n | SharedChannelInviteDeclinedEvent\n | StarAddedEvent\n | StarRemovedEvent;\nexport interface SlackEvent<Type extends string> {\n type: Type;\n subtype?: string;\n}\nexport interface AppRequestedEvent extends SlackEvent<\"app_requested\"> {\n type: \"app_requested\";",
"score": 0.8178330063819885
},
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": " if (req.body.event) {\n if (eventTypesToKeep.includes(req.body.event.type)) {\n return;\n }\n if (\n req.context.authorizeResult.botId === req.body.event.bot_id ||\n req.context.authorizeResult.botUserId === req.context.userId\n ) {\n return { status: 200, body: \"\" };\n }",
"score": 0.813668966293335
},
{
"filename": "src/request/payload/event.ts",
"retrieved_chunk": " api_app_id: string;\n}\nexport interface AppUninstalledEvent extends SlackEvent<\"app_uninstalled\"> {\n type: \"app_uninstalled\";\n}\nexport interface ChannelArchiveEvent extends SlackEvent<\"channel_archive\"> {\n type: \"channel_archive\";\n channel: string;\n user: string;\n is_moved?: number;",
"score": 0.8118165731430054
},
{
"filename": "src/request/request-body.ts",
"retrieved_chunk": "export interface SlackRequestBody {\n type?: string;\n // slash commands\n command?: string;\n // event_callback\n event?: {\n type: string;\n subtype?: string;\n text?: string;\n };",
"score": 0.8005135655403137
},
{
"filename": "src/socket-mode/socket-mode-client.ts",
"retrieved_chunk": " console.info(`Completed a lazy listener execution: ${res}`);\n })\n .catch((err) => {\n console.error(`Failed to run a lazy listener: ${err}`);\n });\n },\n };\n const response = await app.run(request, context);\n // deno-lint-ignore no-explicit-any\n let ack: any = { envelope_id: data.envelope_id };",
"score": 0.8000361919403076
}
] |
typescript
|
if (body.type !== PayloadType.EventsAPI || !body.event) {
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if
|
(isPostedMessageEvent(body.event)) {
|
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/context/context.ts",
"retrieved_chunk": " } else if (body.user_id) {\n return body.user_id;\n } else if (body.event) {\n return extractUserId(body.event);\n } else if (body.message) {\n return extractUserId(body.message);\n } else if (body.previous_message) {\n return extractUserId(body.previous_message);\n }\n return undefined;",
"score": 0.8139650821685791
},
{
"filename": "src/context/context.ts",
"retrieved_chunk": " if (body.channel) {\n if (typeof body.channel === \"string\") {\n return body.channel;\n } else if (typeof body.channel === \"object\" && body.channel.id) {\n return body.channel.id;\n }\n } else if (body.channel_id) {\n return body.channel_id;\n } else if (body.event) {\n return extractChannelId(body.event);",
"score": 0.812615156173706
},
{
"filename": "src/context/context.ts",
"retrieved_chunk": " } else if (body.item) {\n // reaction_added: body[\"event\"][\"item\"]\n return extractChannelId(body.item);\n }\n return undefined;\n}",
"score": 0.8102465867996216
},
{
"filename": "src/middleware/built-in-middleware.ts",
"retrieved_chunk": " if (req.body.event) {\n if (eventTypesToKeep.includes(req.body.event.type)) {\n return;\n }\n if (\n req.context.authorizeResult.botId === req.body.event.bot_id ||\n req.context.authorizeResult.botUserId === req.context.userId\n ) {\n return { status: 200, body: \"\" };\n }",
"score": 0.8047120571136475
},
{
"filename": "src/context/context.ts",
"retrieved_chunk": " } else if (body.team) {\n // With org-wide installations, payload.team in interactivity payloads can be None\n // You need to extract either payload.user.team_id or payload.view.team_id as below\n if (typeof body.team === \"string\") {\n return body.team;\n } else if (body.team.id) {\n return body.team.id;\n }\n } else if (body.authorizations && body.authorizations.length > 0) {\n // To make Events API handling functioning also for shared channels,",
"score": 0.8020102977752686
}
] |
typescript
|
(isPostedMessageEvent(body.event)) {
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(
|
await verifySlackRequest(this.signingSecret, request.headers, rawBody));
|
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/response/response.ts",
"retrieved_chunk": " return new Response(slackResponse, {\n status: 200,\n headers: { \"Content-Type\": \"text/plain;charset=utf-8\" },\n });\n }\n let completeResponse: SlackResponse = {};\n if (\n Object.prototype.hasOwnProperty.call(slackResponse, \"text\") ||\n Object.prototype.hasOwnProperty.call(slackResponse, \"blocks\")\n ) {",
"score": 0.8595949411392212
},
{
"filename": "src/response/response.ts",
"retrieved_chunk": " } else {\n completeResponse = slackResponse as SlackResponse;\n }\n const status = completeResponse.status ? completeResponse.status : 200;\n let contentType = completeResponse.contentType\n ? completeResponse.contentType\n : \"text/plain;charset=utf-8\";\n let bodyString = \"\";\n if (typeof completeResponse.body === \"object\") {\n contentType = \"application/json;charset=utf-8\";",
"score": 0.849436342716217
},
{
"filename": "src/response/response.ts",
"retrieved_chunk": " completeResponse = { status: 200, body: slackResponse as MessageResponse };\n } else if (\n Object.prototype.hasOwnProperty.call(slackResponse, \"response_action\")\n ) {\n completeResponse = { status: 200, body: slackResponse };\n } else if (\n Object.prototype.hasOwnProperty.call(slackResponse, \"options\") ||\n Object.prototype.hasOwnProperty.call(slackResponse, \"option_groups\")\n ) {\n completeResponse = { status: 200, body: slackResponse };",
"score": 0.8482686281204224
},
{
"filename": "src/response/response.ts",
"retrieved_chunk": " | string\n | void\n): Response {\n if (!slackResponse) {\n return new Response(\"\", {\n status: 200,\n headers: { \"Content-Type\": \"text/plain\" },\n });\n }\n if (typeof slackResponse === \"string\") {",
"score": 0.8466284871101379
},
{
"filename": "src/request/request-verification.ts",
"retrieved_chunk": "export async function verifySlackRequest(\n signingSecret: string,\n requsetHeaders: Headers,\n requestBody: string\n) {\n const timestampHeader = requsetHeaders.get(\"x-slack-request-timestamp\");\n if (!timestampHeader) {\n console.log(\"x-slack-request-timestamp header is missing!\");\n return false;\n }",
"score": 0.8398436307907104
}
] |
typescript
|
await verifySlackRequest(this.signingSecret, request.headers, rawBody));
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
|
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
|
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/handler/options-handler.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport { SlackRequest } from \"../request/request\";\nimport { SlackOptionsResponse } from \"../response/response\";\nexport type OptionsAckResponse = SlackOptionsResponse;\nexport interface SlackOptionsHandler<E extends SlackAppEnv, Payload> {\n ack(request: SlackRequest<E, Payload>): Promise<OptionsAckResponse>;\n // Note that a block_suggestion response must be done synchronously.\n // That's why we don't support lazy functions for the pattern.\n}",
"score": 0.8658670783042908
},
{
"filename": "src/request/payload/block-suggestion.ts",
"retrieved_chunk": "import { AnyOption } from \"slack-web-api-client\";\nimport { DataSubmissionView } from \"./view-objects\";\nexport interface BlockSuggestion {\n type: \"block_suggestion\";\n block_id: string;\n action_id: string;\n value: string;\n api_app_id: string;\n team: {\n id: string;",
"score": 0.8305409550666809
},
{
"filename": "src/request/request-body.ts",
"retrieved_chunk": " // shortcut, message_action\n callback_id?: string;\n // block_actions\n actions: {\n type: string;\n block_id: string;\n action_id: string;\n }[];\n // block_suggestion\n block_id?: string;",
"score": 0.8194538354873657
},
{
"filename": "src/handler/handler.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport { SlackRequest } from \"../request/request\";\nimport { SlackResponse } from \"../response/response\";\nexport type AckResponse = SlackResponse | string | void;\nexport interface SlackHandler<E extends SlackAppEnv, Payload> {\n ack(request: SlackRequest<E, Payload>): Promise<AckResponse>;\n lazy(request: SlackRequest<E, Payload>): Promise<void>;\n}",
"score": 0.8075999021530151
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " routes: { events: options.routes?.events ?? \"/slack/events\" },\n });\n this.env = options.env;\n this.installationStore = options.installationStore;\n this.stateStore = options.stateStore ?? new NoStorageStateStore();\n this.oauth = {\n stateCookieName:\n options.oauth?.stateCookieName ?? \"slack-app-oauth-state\",\n onFailure: options.oauth?.onFailure ?? defaultOnFailure,\n onStateValidationError:",
"score": 0.8015279173851013
}
] |
typescript
|
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
|
middleware(middleware: Middleware<E>): SlackApp<E> {
|
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8854179382324219
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " routes: { events: options.routes?.events ?? \"/slack/events\" },\n });\n this.env = options.env;\n this.installationStore = options.installationStore;\n this.stateStore = options.stateStore ?? new NoStorageStateStore();\n this.oauth = {\n stateCookieName:\n options.oauth?.stateCookieName ?? \"slack-app-oauth-state\",\n onFailure: options.oauth?.onFailure ?? defaultOnFailure,\n onStateValidationError:",
"score": 0.8690613508224487
},
{
"filename": "src/middleware/middleware.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport {\n PreAuthorizeSlackMiddlwareRequest,\n SlackMiddlwareRequest,\n} from \"../request/request\";\nimport { SlackResponse } from \"../response/response\";\nexport type PreAuthorizeMiddleware<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<SlackResponse | void>;\nexport type Middleware<E extends SlackAppEnv = SlackAppEnv> = (",
"score": 0.8656647801399231
},
{
"filename": "src/authorization/authorize.ts",
"retrieved_chunk": "import { SlackAppEnv } from \"../app-env\";\nimport { PreAuthorizeSlackMiddlwareRequest } from \"../request/request\";\nimport { AuthorizeResult } from \"./authorize-result\";\nexport type Authorize<E extends SlackAppEnv = SlackAppEnv> = (\n req: PreAuthorizeSlackMiddlwareRequest<E>\n) => Promise<AuthorizeResult>;",
"score": 0.8567003011703491
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " redirectUri:\n options.oidc.redirectUri ?? this.env.SLACK_OIDC_REDIRECT_URI,\n };\n } else {\n this.oidc = undefined;\n }\n this.routes = options.routes\n ? options.routes\n : {\n events: \"/slack/events\",",
"score": 0.8454005718231201
}
] |
typescript
|
middleware(middleware: Middleware<E>): SlackApp<E> {
|
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { SlackApp } from "./app";
import { SlackOAuthEnv } from "./app-env";
import { InstallationStore } from "./oauth/installation-store";
import { NoStorageStateStore, StateStore } from "./oauth/state-store";
import {
renderCompletionPage,
renderStartPage,
} from "./oauth/oauth-page-renderer";
import { generateAuthorizeUrl } from "./oauth/authorize-url-generator";
import { parse as parseCookie } from "./cookie";
import {
SlackAPIClient,
OAuthV2AccessResponse,
OpenIDConnectTokenResponse,
} from "slack-web-api-client";
import { toInstallation } from "./oauth/installation";
import {
AfterInstallation,
BeforeInstallation,
OnFailure,
OnStateValidationError,
defaultOnFailure,
defaultOnStateValidationError,
} from "./oauth/callback";
import {
OpenIDConnectCallback,
defaultOpenIDConnectCallback,
} from "./oidc/callback";
import { generateOIDCAuthorizeUrl } from "./oidc/authorize-url-generator";
import {
InstallationError,
MissingCode,
CompletionPageError,
InstallationStoreError,
OpenIDConnectError,
} from "./oauth/error-codes";
export interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {
env: E;
installationStore: InstallationStore<E>;
stateStore?: StateStore;
oauth?: {
stateCookieName?: string;
beforeInstallation?: BeforeInstallation;
afterInstallation?: AfterInstallation;
onFailure?: OnFailure;
onStateValidationError?: OnStateValidationError;
redirectUri?: string;
};
oidc?: {
stateCookieName?: string;
callback: OpenIDConnectCallback;
onFailure?: OnFailure;
onStateValidationError?: OnStateValidationError;
redirectUri?: string;
};
routes?: {
events: string;
oauth: { start: string; callback: string };
oidc?: { start: string; callback: string };
};
}
export class SlackOAuthApp<E extends SlackOAuthEnv> extends SlackApp<E> {
public env: E;
|
public installationStore: InstallationStore<E>;
|
public stateStore: StateStore;
public oauth: {
stateCookieName?: string;
beforeInstallation?: BeforeInstallation;
afterInstallation?: AfterInstallation;
onFailure: OnFailure;
onStateValidationError: OnStateValidationError;
redirectUri?: string;
};
public oidc?: {
stateCookieName?: string;
callback: OpenIDConnectCallback;
onFailure: OnFailure;
onStateValidationError: OnStateValidationError;
redirectUri?: string;
};
public routes: {
events: string;
oauth: { start: string; callback: string };
oidc?: { start: string; callback: string };
};
constructor(options: SlackOAuthAppOptions<E>) {
super({
env: options.env,
authorize: options.installationStore.toAuthorize(),
routes: { events: options.routes?.events ?? "/slack/events" },
});
this.env = options.env;
this.installationStore = options.installationStore;
this.stateStore = options.stateStore ?? new NoStorageStateStore();
this.oauth = {
stateCookieName:
options.oauth?.stateCookieName ?? "slack-app-oauth-state",
onFailure: options.oauth?.onFailure ?? defaultOnFailure,
onStateValidationError:
options.oauth?.onStateValidationError ?? defaultOnStateValidationError,
redirectUri: options.oauth?.redirectUri ?? this.env.SLACK_REDIRECT_URI,
};
if (options.oidc) {
this.oidc = {
stateCookieName: options.oidc.stateCookieName ?? "slack-app-oidc-state",
onFailure: options.oidc.onFailure ?? defaultOnFailure,
onStateValidationError:
options.oidc.onStateValidationError ?? defaultOnStateValidationError,
callback: defaultOpenIDConnectCallback(this.env),
redirectUri:
options.oidc.redirectUri ?? this.env.SLACK_OIDC_REDIRECT_URI,
};
} else {
this.oidc = undefined;
}
this.routes = options.routes
? options.routes
: {
events: "/slack/events",
oauth: {
start: "/slack/install",
callback: "/slack/oauth_redirect",
},
oidc: {
start: "/slack/login",
callback: "/slack/login/callback",
},
};
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
const url = new URL(request.url);
if (request.method === "GET") {
if (url.pathname === this.routes.oauth.start) {
return await this.handleOAuthStartRequest(request);
} else if (url.pathname === this.routes.oauth.callback) {
return await this.handleOAuthCallbackRequest(request);
}
if (this.routes.oidc) {
if (url.pathname === this.routes.oidc.start) {
return await this.handleOIDCStartRequest(request);
} else if (url.pathname === this.routes.oidc.callback) {
return await this.handleOIDCCallbackRequest(request);
}
}
} else if (request.method === "POST") {
if (url.pathname === this.routes.events) {
return await this.handleEventRequest(request, ctx);
}
}
return new Response("Not found", { status: 404 });
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
return await super.handleEventRequest(request, ctx);
}
// deno-lint-ignore no-unused-vars
async handleOAuthStartRequest(request: Request): Promise<Response> {
const stateValue = await this.stateStore.issueNewState();
const authorizeUrl = generateAuthorizeUrl(stateValue, this.env);
return new Response(renderStartPage(authorizeUrl), {
status: 302,
headers: {
Location: authorizeUrl,
"Set-Cookie": `${this.oauth.stateCookieName}=${stateValue}; Secure; HttpOnly; Path=/; Max-Age=300`,
"Content-Type": "text/html; charset=utf-8",
},
});
}
async handleOAuthCallbackRequest(request: Request): Promise<Response> {
// State parameter validation
await this.#validateStateParameter(
request,
this.routes.oauth.start,
this.oauth.stateCookieName!
);
const { searchParams } = new URL(request.url);
const code = searchParams.get("code");
if (!code) {
return await this.oauth.onFailure(
this.routes.oauth.start,
MissingCode,
request
);
}
const client = new SlackAPIClient(undefined, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
let oauthAccess: OAuthV2AccessResponse | undefined;
try {
// Execute the installation process
oauthAccess = await client.oauth.v2.access({
client_id: this.env.SLACK_CLIENT_ID,
client_secret: this.env.SLACK_CLIENT_SECRET,
redirect_uri: this.oauth.redirectUri,
code,
});
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
InstallationError,
request
);
}
try {
// Store the installation data on this app side
await this.installationStore.save(toInstallation(oauthAccess), request);
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
InstallationStoreError,
request
);
}
try {
// Build the completion page
const authTest = await client.auth.test({
token: oauthAccess.access_token,
});
const enterpriseUrl = authTest.url;
return new Response(
renderCompletionPage(
oauthAccess.app_id!,
oauthAccess.team?.id!,
oauthAccess.is_enterprise_install,
enterpriseUrl
),
{
status: 200,
headers: {
"Set-Cookie": `${this.oauth.stateCookieName}=deleted; Secure; HttpOnly; Path=/; Max-Age=0`,
"Content-Type": "text/html; charset=utf-8",
},
}
);
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
CompletionPageError,
request
);
}
}
// deno-lint-ignore no-unused-vars
async handleOIDCStartRequest(request: Request): Promise<Response> {
if (!this.oidc) {
return new Response("Not found", { status: 404 });
}
const stateValue = await this.stateStore.issueNewState();
const authorizeUrl = generateOIDCAuthorizeUrl(stateValue, this.env);
return new Response(renderStartPage(authorizeUrl), {
status: 302,
headers: {
Location: authorizeUrl,
"Set-Cookie": `${this.oidc.stateCookieName}=${stateValue}; Secure; HttpOnly; Path=/; Max-Age=300`,
"Content-Type": "text/html; charset=utf-8",
},
});
}
async handleOIDCCallbackRequest(request: Request): Promise<Response> {
if (!this.oidc || !this.routes.oidc) {
return new Response("Not found", { status: 404 });
}
// State parameter validation
await this.#validateStateParameter(
request,
this.routes.oidc.start,
this.oidc.stateCookieName!
);
const { searchParams } = new URL(request.url);
const code = searchParams.get("code");
if (!code) {
return await this.oidc.onFailure(
this.routes.oidc.start,
MissingCode,
request
);
}
try {
const client = new SlackAPIClient(undefined, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
const apiResponse: OpenIDConnectTokenResponse =
await client.openid.connect.token({
client_id: this.env.SLACK_CLIENT_ID,
client_secret: this.env.SLACK_CLIENT_SECRET,
redirect_uri: this.oidc.redirectUri,
code,
});
return await this.oidc.callback(apiResponse, request);
} catch (e) {
console.log(e);
return await this.oidc.onFailure(
this.routes.oidc.start,
OpenIDConnectError,
request
);
}
}
async #validateStateParameter(
request: Request,
startPath: string,
cookieName: string
) {
const { searchParams } = new URL(request.url);
const queryState = searchParams.get("state");
const cookie = parseCookie(request.headers.get("Cookie") || "");
const cookieState = cookie[cookieName];
if (
queryState !== cookieState ||
!(await this.stateStore.consume(queryState))
) {
if (startPath === this.routes.oauth.start) {
return await this.oauth.onStateValidationError(startPath, request);
} else if (
this.oidc &&
this.routes.oidc &&
startPath === this.routes.oidc.start
) {
return await this.oidc.onStateValidationError(startPath, request);
}
}
}
}
|
src/oauth-app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/app.ts",
"retrieved_chunk": "export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {\n public env: E;\n public client: SlackAPIClient;\n public authorize: Authorize<E>;\n public routes: { events: string | undefined };\n public signingSecret: string;\n public appLevelToken: string | undefined;\n public socketMode: boolean;\n public socketModeClient: SocketModeClient | undefined;\n // deno-lint-ignore no-explicit-any",
"score": 0.9089153409004211
},
{
"filename": "src/app.ts",
"retrieved_chunk": "export interface SlackAppOptions<\n E extends SlackEdgeAppEnv | SlackSocketModeAppEnv\n> {\n env: E;\n authorize?: Authorize<E>;\n routes?: {\n events: string;\n };\n socketMode?: boolean;\n}",
"score": 0.8950526714324951
},
{
"filename": "src/oauth/installation-store.ts",
"retrieved_chunk": "import { SlackOAuthEnv } from \"../app-env\";\nimport { Authorize } from \"../authorization/authorize\";\nimport { Installation } from \"./installation\";\nexport interface InstallationStoreQuery {\n enterpriseId?: string;\n teamId?: string;\n userId?: string;\n isEnterpriseInstall?: boolean;\n}\nexport interface InstallationStore<E extends SlackOAuthEnv> {",
"score": 0.8853778839111328
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_SCOPES: string;\n SLACK_USER_SCOPES?: string;\n SLACK_REDIRECT_URI?: string;\n SLACK_OIDC_SCOPES?: string;\n SLACK_OIDC_REDIRECT_URI?: string;\n SLACK_USER_TOKEN_RESOLUTION?: \"installer\" | \"actor\";\n};\nexport type SlackOIDCEnv = SlackAppEnv & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.8813952207565308
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.8782501220703125
}
] |
typescript
|
public installationStore: InstallationStore<E>;
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient: SocketModeClient | undefined;
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> =
|
await parseRequestBody(
request.headers,
rawBody
);
|
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/request/request-parser.ts",
"retrieved_chunk": " ) {\n return JSON.parse(requestBody);\n }\n const params = new URLSearchParams(requestBody);\n if (params.has(\"payload\")) {\n const payload = params.get(\"payload\")!;\n return JSON.parse(payload);\n }\n // deno-lint-ignore no-explicit-any\n const formBody: any = {};",
"score": 0.8766539096832275
},
{
"filename": "src/request/request-parser.ts",
"retrieved_chunk": "// deno-lint-ignore require-await\nexport async function parseRequestBody(\n requestHeaders: Headers,\n requestBody: string\n): // deno-lint-ignore no-explicit-any\nPromise<Record<string, any>> {\n const contentType = requestHeaders.get(\"content-type\");\n if (\n contentType?.startsWith(\"application/json\") ||\n requestBody.startsWith(\"{\")",
"score": 0.869691014289856
},
{
"filename": "src/request/request-verification.ts",
"retrieved_chunk": "export async function verifySlackRequest(\n signingSecret: string,\n requsetHeaders: Headers,\n requestBody: string\n) {\n const timestampHeader = requsetHeaders.get(\"x-slack-request-timestamp\");\n if (!timestampHeader) {\n console.log(\"x-slack-request-timestamp header is missing!\");\n return false;\n }",
"score": 0.852794349193573
},
{
"filename": "src/request/request.ts",
"retrieved_chunk": " context: PreAuthorizeSlackAppContext;\n // deno-lint-ignore no-explicit-any\n body: Record<string, any>;\n retryNum?: number;\n retryReason?: string;\n rawBody: string;\n headers: Headers;\n}\nexport type PreAuthorizeSlackMiddlwareRequest<E extends SlackAppEnv> =\n SlackMiddlewareRequestBase<E> & {",
"score": 0.841316819190979
},
{
"filename": "src/socket-mode/socket-mode-client.ts",
"retrieved_chunk": " const request: Request = new Request(ws.url, {\n method: \"POST\",\n headers: new Headers({ \"content-type\": \"application/json\" }),\n body: new Blob([payload]).stream(),\n });\n const context: ExecutionContext = {\n // deno-lint-ignore require-await\n waitUntil: async (promise) => {\n promise\n .then((res) => {",
"score": 0.8299250602722168
}
] |
typescript
|
await parseRequestBody(
request.headers,
rawBody
);
|
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { SlackApp } from "./app";
import { SlackOAuthEnv } from "./app-env";
import { InstallationStore } from "./oauth/installation-store";
import { NoStorageStateStore, StateStore } from "./oauth/state-store";
import {
renderCompletionPage,
renderStartPage,
} from "./oauth/oauth-page-renderer";
import { generateAuthorizeUrl } from "./oauth/authorize-url-generator";
import { parse as parseCookie } from "./cookie";
import {
SlackAPIClient,
OAuthV2AccessResponse,
OpenIDConnectTokenResponse,
} from "slack-web-api-client";
import { toInstallation } from "./oauth/installation";
import {
AfterInstallation,
BeforeInstallation,
OnFailure,
OnStateValidationError,
defaultOnFailure,
defaultOnStateValidationError,
} from "./oauth/callback";
import {
OpenIDConnectCallback,
defaultOpenIDConnectCallback,
} from "./oidc/callback";
import { generateOIDCAuthorizeUrl } from "./oidc/authorize-url-generator";
import {
InstallationError,
MissingCode,
CompletionPageError,
InstallationStoreError,
OpenIDConnectError,
} from "./oauth/error-codes";
export interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {
env: E;
installationStore: InstallationStore<E>;
stateStore?: StateStore;
oauth?: {
stateCookieName?: string;
beforeInstallation?: BeforeInstallation;
afterInstallation?: AfterInstallation;
onFailure?: OnFailure;
onStateValidationError?: OnStateValidationError;
redirectUri?: string;
};
oidc?: {
stateCookieName?: string;
callback: OpenIDConnectCallback;
onFailure?: OnFailure;
onStateValidationError?: OnStateValidationError;
redirectUri?: string;
};
routes?: {
events: string;
oauth: { start: string; callback: string };
oidc?: { start: string; callback: string };
};
}
export class SlackOAuthApp<E extends SlackOAuthEnv> extends SlackApp<E> {
public env: E;
public installationStore: InstallationStore<E>;
public stateStore: StateStore;
public oauth: {
stateCookieName?: string;
beforeInstallation?: BeforeInstallation;
afterInstallation?: AfterInstallation;
onFailure: OnFailure;
onStateValidationError: OnStateValidationError;
redirectUri?: string;
};
public oidc?: {
stateCookieName?: string;
callback: OpenIDConnectCallback;
onFailure: OnFailure;
onStateValidationError: OnStateValidationError;
redirectUri?: string;
};
public routes: {
events: string;
oauth: { start: string; callback: string };
oidc?: { start: string; callback: string };
};
constructor(options: SlackOAuthAppOptions<E>) {
super({
env: options.env,
authorize: options.installationStore.toAuthorize(),
routes: { events: options.routes?.events ?? "/slack/events" },
});
this.env = options.env;
this.installationStore = options.installationStore;
this.stateStore = options.stateStore ?? new NoStorageStateStore();
this.oauth = {
stateCookieName:
options.oauth?.stateCookieName ?? "slack-app-oauth-state",
onFailure: options.oauth?.onFailure ?? defaultOnFailure,
onStateValidationError:
options.oauth?.onStateValidationError ?? defaultOnStateValidationError,
redirectUri: options.oauth?.redirectUri ?? this.env.SLACK_REDIRECT_URI,
};
if (options.oidc) {
this.oidc = {
stateCookieName: options.oidc.stateCookieName ?? "slack-app-oidc-state",
onFailure: options.oidc.onFailure ?? defaultOnFailure,
onStateValidationError:
options.oidc.onStateValidationError ?? defaultOnStateValidationError,
callback: defaultOpenIDConnectCallback(this.env),
redirectUri:
options.oidc.redirectUri ?? this.env.SLACK_OIDC_REDIRECT_URI,
};
} else {
this.oidc = undefined;
}
this.routes = options.routes
? options.routes
: {
events: "/slack/events",
oauth: {
start: "/slack/install",
callback: "/slack/oauth_redirect",
},
oidc: {
start: "/slack/login",
callback: "/slack/login/callback",
},
};
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
const url = new URL(request.url);
if (request.method === "GET") {
if (url.pathname === this.routes.oauth.start) {
return await this.handleOAuthStartRequest(request);
} else if (url.pathname === this.routes.oauth.callback) {
return await this.handleOAuthCallbackRequest(request);
}
if (this.routes.oidc) {
if (url.pathname === this.routes.oidc.start) {
return await this.handleOIDCStartRequest(request);
} else if (url.pathname === this.routes.oidc.callback) {
return await this.handleOIDCCallbackRequest(request);
}
}
} else if (request.method === "POST") {
if (url.pathname === this.routes.events) {
return await this.handleEventRequest(request, ctx);
}
}
return new Response("Not found", { status: 404 });
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
return await super.handleEventRequest(request, ctx);
}
// deno-lint-ignore no-unused-vars
async handleOAuthStartRequest(request: Request): Promise<Response> {
const stateValue = await this.stateStore.issueNewState();
const authorizeUrl = generateAuthorizeUrl(stateValue, this.env);
return new Response(renderStartPage(authorizeUrl), {
status: 302,
headers: {
Location: authorizeUrl,
"Set-Cookie": `${this.oauth.stateCookieName}=${stateValue}; Secure; HttpOnly; Path=/; Max-Age=300`,
"Content-Type": "text/html; charset=utf-8",
},
});
}
async handleOAuthCallbackRequest(request: Request): Promise<Response> {
// State parameter validation
await this.#validateStateParameter(
request,
this.routes.oauth.start,
this.oauth.stateCookieName!
);
const { searchParams } = new URL(request.url);
const code = searchParams.get("code");
if (!code) {
return await this.oauth.onFailure(
this.routes.oauth.start,
MissingCode,
request
);
}
const client = new SlackAPIClient(undefined, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
let oauthAccess: OAuthV2AccessResponse | undefined;
try {
// Execute the installation process
oauthAccess = await client.oauth.v2.access({
client_id: this.env.SLACK_CLIENT_ID,
client_secret: this.env.SLACK_CLIENT_SECRET,
redirect_uri: this.oauth.redirectUri,
code,
});
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
InstallationError,
request
);
}
try {
// Store the installation data on this app side
await this.installationStore.save(toInstallation(oauthAccess), request);
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
InstallationStoreError,
request
);
}
try {
// Build the completion page
const authTest = await client.auth.test({
token: oauthAccess.access_token,
});
const enterpriseUrl = authTest.url;
return new Response(
renderCompletionPage(
oauthAccess.app_id!,
oauthAccess.team?.id!,
oauthAccess.is_enterprise_install,
enterpriseUrl
),
{
status: 200,
headers: {
"Set-Cookie": `${this.oauth.stateCookieName}=deleted; Secure; HttpOnly; Path=/; Max-Age=0`,
"Content-Type": "text/html; charset=utf-8",
},
}
);
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
CompletionPageError,
request
);
}
}
// deno-lint-ignore no-unused-vars
async handleOIDCStartRequest(request: Request): Promise<Response> {
if (!this.oidc) {
return new Response("Not found", { status: 404 });
}
const stateValue = await this.stateStore.issueNewState();
const authorizeUrl = generateOIDCAuthorizeUrl(stateValue, this.env);
return new Response(renderStartPage(authorizeUrl), {
status: 302,
headers: {
Location: authorizeUrl,
"Set-Cookie": `${this.oidc.stateCookieName}=${stateValue}; Secure; HttpOnly; Path=/; Max-Age=300`,
"Content-Type": "text/html; charset=utf-8",
},
});
}
async handleOIDCCallbackRequest(request: Request): Promise<Response> {
if (!this.oidc || !this.routes.oidc) {
return new Response("Not found", { status: 404 });
}
// State parameter validation
await this.#validateStateParameter(
request,
this.routes.oidc.start,
this.oidc.stateCookieName!
);
const { searchParams } = new URL(request.url);
const code = searchParams.get("code");
if (!code) {
return await this.oidc.onFailure(
this.routes.oidc.start,
MissingCode,
request
);
}
try {
const client = new SlackAPIClient(undefined, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
const apiResponse: OpenIDConnectTokenResponse =
await client.openid.connect.token({
client_id: this.env.SLACK_CLIENT_ID,
client_secret: this.env.SLACK_CLIENT_SECRET,
redirect_uri: this.oidc.redirectUri,
code,
});
return await this.oidc.callback(apiResponse, request);
} catch (e) {
console.log(e);
return await this.oidc.onFailure(
this.routes.oidc.start,
OpenIDConnectError,
request
);
}
}
async #validateStateParameter(
request: Request,
startPath: string,
cookieName: string
) {
const { searchParams } = new URL(request.url);
const queryState = searchParams.get("state");
const cookie =
|
parseCookie(request.headers.get("Cookie") || "");
|
const cookieState = cookie[cookieName];
if (
queryState !== cookieState ||
!(await this.stateStore.consume(queryState))
) {
if (startPath === this.routes.oauth.start) {
return await this.oauth.onStateValidationError(startPath, request);
} else if (
this.oidc &&
this.routes.oidc &&
startPath === this.routes.oidc.start
) {
return await this.oidc.onStateValidationError(startPath, request);
}
}
}
}
|
src/oauth-app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/oauth/callback.ts",
"retrieved_chunk": "export type OnStateValidationError = (\n startPath: string,\n req: Request\n) => Promise<Response>;\n// deno-lint-ignore require-await\nexport const defaultOnStateValidationError = async (\n startPath: string,\n // deno-lint-ignore no-unused-vars\n req: Request\n) => {",
"score": 0.8201440572738647
},
{
"filename": "src/oauth/callback.ts",
"retrieved_chunk": " return new Response(renderErrorPage(startPath, InvalidStateParameter), {\n status: 400,\n headers: { \"Content-Type\": \"text/html; charset=utf-8\" },\n });\n};\nexport type OnFailure = (\n startPath: string,\n reason: OAuthErrorCode,\n req: Request\n) => Promise<Response>;",
"score": 0.7920830249786377
},
{
"filename": "src/request/request-parser.ts",
"retrieved_chunk": " ) {\n return JSON.parse(requestBody);\n }\n const params = new URLSearchParams(requestBody);\n if (params.has(\"payload\")) {\n const payload = params.get(\"payload\")!;\n return JSON.parse(payload);\n }\n // deno-lint-ignore no-explicit-any\n const formBody: any = {};",
"score": 0.7882514595985413
},
{
"filename": "src/app.ts",
"retrieved_chunk": " ): Promise<Response> {\n // If the routes.events is missing, any URLs can work for handing requests from Slack\n if (this.routes.events) {\n const { pathname } = new URL(request.url);\n if (pathname !== this.routes.events) {\n return new Response(\"Not found\", { status: 404 });\n }\n }\n // To avoid the following warning by Cloudflware, parse the body as Blob first\n // Called .text() on an HTTP body which does not appear to be text ..",
"score": 0.7869008779525757
},
{
"filename": "src/app.ts",
"retrieved_chunk": " const blobRequestBody = await request.blob();\n // We can safely assume the incoming request body is always text data\n const rawBody: string = await blobRequestBody.text();\n // For Request URL verification\n if (rawBody.includes(\"ssl_check=\")) {\n // Slack does not send the x-slack-signature header for this pattern.\n // Thus, we need to check the pattern before verifying a request.\n const bodyParams = new URLSearchParams(rawBody);\n if (bodyParams.get(\"ssl_check\") === \"1\" && bodyParams.get(\"token\")) {\n return new Response(\"\", { status: 200 });",
"score": 0.7803342938423157
}
] |
typescript
|
parseCookie(request.headers.get("Cookie") || "");
|
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { SlackApp } from "./app";
import { SlackOAuthEnv } from "./app-env";
import { InstallationStore } from "./oauth/installation-store";
import { NoStorageStateStore, StateStore } from "./oauth/state-store";
import {
renderCompletionPage,
renderStartPage,
} from "./oauth/oauth-page-renderer";
import { generateAuthorizeUrl } from "./oauth/authorize-url-generator";
import { parse as parseCookie } from "./cookie";
import {
SlackAPIClient,
OAuthV2AccessResponse,
OpenIDConnectTokenResponse,
} from "slack-web-api-client";
import { toInstallation } from "./oauth/installation";
import {
AfterInstallation,
BeforeInstallation,
OnFailure,
OnStateValidationError,
defaultOnFailure,
defaultOnStateValidationError,
} from "./oauth/callback";
import {
OpenIDConnectCallback,
defaultOpenIDConnectCallback,
} from "./oidc/callback";
import { generateOIDCAuthorizeUrl } from "./oidc/authorize-url-generator";
import {
InstallationError,
MissingCode,
CompletionPageError,
InstallationStoreError,
OpenIDConnectError,
} from "./oauth/error-codes";
export interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {
env: E;
installationStore: InstallationStore<E>;
stateStore?: StateStore;
oauth?: {
stateCookieName?: string;
beforeInstallation?: BeforeInstallation;
afterInstallation?: AfterInstallation;
onFailure?: OnFailure;
onStateValidationError?: OnStateValidationError;
redirectUri?: string;
};
oidc?: {
stateCookieName?: string;
callback: OpenIDConnectCallback;
onFailure?: OnFailure;
onStateValidationError?: OnStateValidationError;
redirectUri?: string;
};
routes?: {
events: string;
oauth: { start: string; callback: string };
oidc?: { start: string; callback: string };
};
}
export class SlackOAuthApp<E extends SlackOAuthEnv> extends SlackApp<E> {
public env: E;
public installationStore: InstallationStore<E>;
public stateStore: StateStore;
public oauth: {
stateCookieName?: string;
beforeInstallation?: BeforeInstallation;
afterInstallation?: AfterInstallation;
onFailure: OnFailure;
onStateValidationError: OnStateValidationError;
redirectUri?: string;
};
public oidc?: {
stateCookieName?: string;
callback: OpenIDConnectCallback;
onFailure: OnFailure;
onStateValidationError: OnStateValidationError;
redirectUri?: string;
};
public routes: {
events: string;
oauth: { start: string; callback: string };
oidc?: { start: string; callback: string };
};
constructor(options: SlackOAuthAppOptions<E>) {
super({
env: options.env,
authorize: options.installationStore.toAuthorize(),
routes: { events: options.routes?.events ?? "/slack/events" },
});
this.env = options.env;
this.installationStore = options.installationStore;
this.stateStore = options.stateStore ?? new NoStorageStateStore();
this.oauth = {
stateCookieName:
options.oauth?.stateCookieName ?? "slack-app-oauth-state",
onFailure: options.oauth?.onFailure ?? defaultOnFailure,
onStateValidationError:
options.oauth?.onStateValidationError ?? defaultOnStateValidationError,
redirectUri: options.oauth?.redirectUri ?? this.env.SLACK_REDIRECT_URI,
};
if (options.oidc) {
this.oidc = {
stateCookieName: options.oidc.stateCookieName ?? "slack-app-oidc-state",
onFailure: options.oidc.onFailure ?? defaultOnFailure,
onStateValidationError:
options.oidc.onStateValidationError ?? defaultOnStateValidationError,
callback: defaultOpenIDConnectCallback(this.env),
redirectUri:
options.oidc.redirectUri ?? this.env.SLACK_OIDC_REDIRECT_URI,
};
} else {
this.oidc = undefined;
}
this.routes = options.routes
? options.routes
: {
events: "/slack/events",
oauth: {
start: "/slack/install",
callback: "/slack/oauth_redirect",
},
oidc: {
start: "/slack/login",
callback: "/slack/login/callback",
},
};
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
const url = new URL(request.url);
if (request.method === "GET") {
if (url.pathname === this.routes.oauth.start) {
return await this.handleOAuthStartRequest(request);
} else if (url.pathname === this.routes.oauth.callback) {
return await this.handleOAuthCallbackRequest(request);
}
if (this.routes.oidc) {
if (url.pathname === this.routes.oidc.start) {
return await this.handleOIDCStartRequest(request);
} else if (url.pathname === this.routes.oidc.callback) {
return await this.handleOIDCCallbackRequest(request);
}
}
} else if (request.method === "POST") {
if (url.pathname === this.routes.events) {
return await this.handleEventRequest(request, ctx);
}
}
return new Response("Not found", { status: 404 });
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
return await super.handleEventRequest(request, ctx);
}
// deno-lint-ignore no-unused-vars
async handleOAuthStartRequest(request: Request): Promise<Response> {
const stateValue = await this.stateStore.issueNewState();
const authorizeUrl = generateAuthorizeUrl(stateValue, this.env);
return new Response(renderStartPage(authorizeUrl), {
status: 302,
headers: {
Location: authorizeUrl,
"Set-Cookie": `${this.oauth.stateCookieName}=${stateValue}; Secure; HttpOnly; Path=/; Max-Age=300`,
"Content-Type": "text/html; charset=utf-8",
},
});
}
async handleOAuthCallbackRequest(request: Request): Promise<Response> {
// State parameter validation
await this.#validateStateParameter(
request,
this.routes.oauth.start,
this.oauth.stateCookieName!
);
const { searchParams } = new URL(request.url);
const code = searchParams.get("code");
if (!code) {
return await this.oauth.onFailure(
this.routes.oauth.start,
MissingCode,
request
);
}
const client = new SlackAPIClient(undefined, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
let oauthAccess: OAuthV2AccessResponse | undefined;
try {
// Execute the installation process
oauthAccess = await client.oauth.v2.access({
client_id: this.env.SLACK_CLIENT_ID,
client_secret: this.env.SLACK_CLIENT_SECRET,
redirect_uri: this.oauth.redirectUri,
code,
});
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
InstallationError,
request
);
}
try {
// Store the installation data on this app side
|
await this.installationStore.save(toInstallation(oauthAccess), request);
|
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
InstallationStoreError,
request
);
}
try {
// Build the completion page
const authTest = await client.auth.test({
token: oauthAccess.access_token,
});
const enterpriseUrl = authTest.url;
return new Response(
renderCompletionPage(
oauthAccess.app_id!,
oauthAccess.team?.id!,
oauthAccess.is_enterprise_install,
enterpriseUrl
),
{
status: 200,
headers: {
"Set-Cookie": `${this.oauth.stateCookieName}=deleted; Secure; HttpOnly; Path=/; Max-Age=0`,
"Content-Type": "text/html; charset=utf-8",
},
}
);
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
CompletionPageError,
request
);
}
}
// deno-lint-ignore no-unused-vars
async handleOIDCStartRequest(request: Request): Promise<Response> {
if (!this.oidc) {
return new Response("Not found", { status: 404 });
}
const stateValue = await this.stateStore.issueNewState();
const authorizeUrl = generateOIDCAuthorizeUrl(stateValue, this.env);
return new Response(renderStartPage(authorizeUrl), {
status: 302,
headers: {
Location: authorizeUrl,
"Set-Cookie": `${this.oidc.stateCookieName}=${stateValue}; Secure; HttpOnly; Path=/; Max-Age=300`,
"Content-Type": "text/html; charset=utf-8",
},
});
}
async handleOIDCCallbackRequest(request: Request): Promise<Response> {
if (!this.oidc || !this.routes.oidc) {
return new Response("Not found", { status: 404 });
}
// State parameter validation
await this.#validateStateParameter(
request,
this.routes.oidc.start,
this.oidc.stateCookieName!
);
const { searchParams } = new URL(request.url);
const code = searchParams.get("code");
if (!code) {
return await this.oidc.onFailure(
this.routes.oidc.start,
MissingCode,
request
);
}
try {
const client = new SlackAPIClient(undefined, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
const apiResponse: OpenIDConnectTokenResponse =
await client.openid.connect.token({
client_id: this.env.SLACK_CLIENT_ID,
client_secret: this.env.SLACK_CLIENT_SECRET,
redirect_uri: this.oidc.redirectUri,
code,
});
return await this.oidc.callback(apiResponse, request);
} catch (e) {
console.log(e);
return await this.oidc.onFailure(
this.routes.oidc.start,
OpenIDConnectError,
request
);
}
}
async #validateStateParameter(
request: Request,
startPath: string,
cookieName: string
) {
const { searchParams } = new URL(request.url);
const queryState = searchParams.get("state");
const cookie = parseCookie(request.headers.get("Cookie") || "");
const cookieState = cookie[cookieName];
if (
queryState !== cookieState ||
!(await this.stateStore.consume(queryState))
) {
if (startPath === this.routes.oauth.start) {
return await this.oauth.onStateValidationError(startPath, request);
} else if (
this.oidc &&
this.routes.oidc &&
startPath === this.routes.oidc.start
) {
return await this.oidc.onStateValidationError(startPath, request);
}
}
}
}
|
src/oauth-app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/oauth/callback.ts",
"retrieved_chunk": "import { InvalidStateParameter, OAuthErrorCode } from \"./error-codes\";\nimport { Installation } from \"./installation\";\nimport { renderErrorPage } from \"./oauth-page-renderer\";\nexport type BeforeInstallation = (\n req: Request\n) => Promise<Response | undefined | void>;\nexport type AfterInstallation = (\n installation: Installation,\n req: Request\n) => Promise<Response | undefined | void>;",
"score": 0.8243993520736694
},
{
"filename": "src/oauth/installation-store.ts",
"retrieved_chunk": " save(installation: Installation, request: Request | undefined): Promise<void>;\n findBotInstallation(\n query: InstallationStoreQuery\n ): Promise<Installation | undefined>;\n findUserInstallation(\n query: InstallationStoreQuery\n ): Promise<Installation | undefined>;\n toAuthorize(): Authorize<E>;\n}",
"score": 0.8199449777603149
},
{
"filename": "src/oauth/installation.ts",
"retrieved_chunk": " incoming_webhook_configuration_url: oauthAccess.incoming_webhook?.url,\n };\n return installation;\n}",
"score": 0.8172743320465088
},
{
"filename": "src/oauth/installation.ts",
"retrieved_chunk": " incoming_webhook_channel_id?: string;\n incoming_webhook_configuration_url?: string;\n}\nexport function toInstallation(\n oauthAccess: OAuthV2AccessResponse\n): Installation {\n const installation: Installation = {\n app_id: oauthAccess.app_id!,\n is_enterprise_install: oauthAccess.is_enterprise_install,\n enterprise_id: oauthAccess.enterprise?.id,",
"score": 0.816808819770813
},
{
"filename": "src/oauth/error-codes.ts",
"retrieved_chunk": " message: \"The code parameter is missing\",\n};\nexport const InstallationError: OAuthErrorCode = {\n code: \"installation-error\",\n message: \"The installation process failed\",\n};\nexport const InstallationStoreError: OAuthErrorCode = {\n code: \"installation-store-error\",\n message: \"Saving the installation data failed\",\n};",
"score": 0.8087154626846313
}
] |
typescript
|
await this.installationStore.save(toInstallation(oauthAccess), request);
|
import { SlackAPIClient, isDebugLogEnabled } from "slack-web-api-client";
import { SlackApp } from "../app";
import { ConfigError, SocketModeError } from "../errors";
import { ExecutionContext } from "../execution-context";
import { SlackSocketModeAppEnv } from "../app-env";
// TODO: Implement proper reconnection logic
// TODO: Add connection monitor like 1st party SDKs do
// TODO: Add Bun support (the runtime does not work well with Socket Mode)
export class SocketModeClient {
public app: SlackApp<SlackSocketModeAppEnv>;
public appLevelToken: string;
public ws: WebSocket | undefined;
constructor(
// deno-lint-ignore no-explicit-any
app: SlackApp<any>
) {
if (!app.socketMode) {
throw new ConfigError(
"socketMode: true must be set for running with Socket Mode"
);
}
if (!app.appLevelToken) {
throw new ConfigError(
"appLevelToken must be set for running with Socket Mode"
);
}
this.app = app as SlackApp<SlackSocketModeAppEnv>;
this.appLevelToken = app.appLevelToken;
console.warn(
"WARNING: The Socket Mode support provided by slack-edge is still experimental and is not designed to handle reconnections for production-grade applications. It is recommended to use this mode only for local development and testing purposes."
);
}
async connect() {
const client = new SlackAPIClient(this.appLevelToken);
try {
const newConnection = await client.apps.connections.open();
this.ws = new WebSocket(newConnection.url!);
} catch (e) {
|
throw new SocketModeError(
`Failed to establish a new WSS connection: ${e}`
);
|
}
if (this.ws) {
const ws = this.ws;
// deno-lint-ignore require-await
ws.onopen = async (ev) => {
// TODO: make this customizable
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(
`Now the Socket Mode client is connected to Slack: ${JSON.stringify(
ev
)}`
);
}
};
// deno-lint-ignore require-await
ws.onclose = async (ev) => {
// TODO: make this customizable
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(
`The Socket Mode client is disconnected from Slack: ${JSON.stringify(
ev
)}`
);
}
};
// deno-lint-ignore require-await
ws.onerror = async (e) => {
// TODO: make this customizable
console.error(
`An error was thrown by the Socket Mode connection: ${e}`
);
};
const app = this.app;
ws.onmessage = async (ev) => {
try {
if (
ev.data &&
typeof ev.data === "string" &&
ev.data.startsWith("{")
) {
const data = JSON.parse(ev.data);
if (data.type === "hello") {
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received hello data ***\n ${ev.data}`);
}
return;
}
const payload = JSON.stringify(data.payload);
console.log(payload);
const request: Request = new Request(ws.url, {
method: "POST",
headers: new Headers({ "content-type": "application/json" }),
body: new Blob([payload]).stream(),
});
const context: ExecutionContext = {
// deno-lint-ignore require-await
waitUntil: async (promise) => {
promise
.then((res) => {
console.info(`Completed a lazy listener execution: ${res}`);
})
.catch((err) => {
console.error(`Failed to run a lazy listener: ${err}`);
});
},
};
const response = await app.run(request, context);
// deno-lint-ignore no-explicit-any
let ack: any = { envelope_id: data.envelope_id };
if (response.body) {
const contentType = response.headers.get("Content-Type");
if (contentType && contentType.startsWith("text/plain")) {
const text = await response.text();
ack = { envelope_id: data.envelope_id, payload: { text } };
} else {
const json = await response.json();
ack = { envelope_id: data.envelope_id, payload: { ...json } };
}
}
ws.send(JSON.stringify(ack));
} else {
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received non-JSON data ***\n ${ev.data}`);
}
}
} catch (e) {
console.error(`Failed to handle a WebSocke message: ${e}`);
}
};
}
}
// deno-lint-ignore require-await
async disconnect(): Promise<void> {
if (this.ws) {
this.ws.close();
this.ws = undefined;
}
}
}
|
src/socket-mode/socket-mode-client.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/app.ts",
"retrieved_chunk": " ): Promise<Response> {\n return await this.handleEventRequest(request, ctx);\n }\n async connect(): Promise<void> {\n if (!this.socketMode) {\n throw new ConfigError(\n \"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!\"\n );\n }\n this.socketModeClient = new SocketModeClient(this);",
"score": 0.891596794128418
},
{
"filename": "src/app.ts",
"retrieved_chunk": " }\n this.env = options.env;\n this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {\n logLevel: this.env.SLACK_LOGGING_LEVEL,\n });\n this.appLevelToken = options.env.SLACK_APP_TOKEN;\n this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;\n if (this.socketMode) {\n this.signingSecret = \"\";\n } else {",
"score": 0.8408665657043457
},
{
"filename": "src/errors.ts",
"retrieved_chunk": " }\n}\nexport class SocketModeError extends Error {\n constructor(message: string) {\n super(message);\n this.name = \"SocketModeError\";\n }\n}",
"score": 0.8278390169143677
},
{
"filename": "src/app.ts",
"retrieved_chunk": "export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {\n public env: E;\n public client: SlackAPIClient;\n public authorize: Authorize<E>;\n public routes: { events: string | undefined };\n public signingSecret: string;\n public appLevelToken: string | undefined;\n public socketMode: boolean;\n public socketModeClient: SocketModeClient | undefined;\n // deno-lint-ignore no-explicit-any",
"score": 0.8193002939224243
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " const client = new SlackAPIClient(undefined, {\n logLevel: this.env.SLACK_LOGGING_LEVEL,\n });\n let oauthAccess: OAuthV2AccessResponse | undefined;\n try {\n // Execute the installation process\n oauthAccess = await client.oauth.v2.access({\n client_id: this.env.SLACK_CLIENT_ID,\n client_secret: this.env.SLACK_CLIENT_SECRET,\n redirect_uri: this.oauth.redirectUri,",
"score": 0.8060556650161743
}
] |
typescript
|
throw new SocketModeError(
`Failed to establish a new WSS connection: ${e}`
);
|
import { SlackAppEnv, SlackEdgeAppEnv, SlackSocketModeAppEnv } from "./app-env";
import { parseRequestBody } from "./request/request-parser";
import { verifySlackRequest } from "./request/request-verification";
import { AckResponse, SlackHandler } from "./handler/handler";
import { SlackRequestBody } from "./request/request-body";
import {
PreAuthorizeSlackMiddlwareRequest,
SlackRequestWithRespond,
SlackMiddlwareRequest,
SlackRequestWithOptionalRespond,
SlackRequest,
SlackRequestWithChannelId,
} from "./request/request";
import { SlashCommand } from "./request/payload/slash-command";
import { toCompleteResponse } from "./response/response";
import {
SlackEvent,
AnySlackEvent,
AnySlackEventWithChannelId,
} from "./request/payload/event";
import { ResponseUrlSender, SlackAPIClient } from "slack-web-api-client";
import {
builtBaseContext,
SlackAppContext,
SlackAppContextWithChannelId,
SlackAppContextWithRespond,
} from "./context/context";
import { PreAuthorizeMiddleware, Middleware } from "./middleware/middleware";
import { isDebugLogEnabled, prettyPrint } from "slack-web-api-client";
import { Authorize } from "./authorization/authorize";
import { AuthorizeResult } from "./authorization/authorize-result";
import {
ignoringSelfEvents,
urlVerification,
} from "./middleware/built-in-middleware";
import { ConfigError } from "./errors";
import { GlobalShortcut } from "./request/payload/global-shortcut";
import { MessageShortcut } from "./request/payload/message-shortcut";
import {
BlockAction,
BlockElementAction,
BlockElementTypes,
} from "./request/payload/block-action";
import { ViewSubmission } from "./request/payload/view-submission";
import { ViewClosed } from "./request/payload/view-closed";
import { BlockSuggestion } from "./request/payload/block-suggestion";
import {
OptionsAckResponse,
SlackOptionsHandler,
} from "./handler/options-handler";
import { SlackViewHandler, ViewAckResponse } from "./handler/view-handler";
import {
MessageAckResponse,
SlackMessageHandler,
} from "./handler/message-handler";
import { singleTeamAuthorize } from "./authorization/single-team-authorize";
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { PayloadType } from "./request/payload-types";
import { isPostedMessageEvent } from "./utility/message-events";
import { SocketModeClient } from "./socket-mode/socket-mode-client";
export interface SlackAppOptions<
E extends SlackEdgeAppEnv | SlackSocketModeAppEnv
> {
env: E;
authorize?: Authorize<E>;
routes?: {
events: string;
};
socketMode?: boolean;
}
export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {
public env: E;
public client: SlackAPIClient;
public authorize: Authorize<E>;
public routes: { events: string | undefined };
public signingSecret: string;
public appLevelToken: string | undefined;
public socketMode: boolean;
public socketModeClient
|
: SocketModeClient | undefined;
|
// deno-lint-ignore no-explicit-any
public preAuthorizeMiddleware: PreAuthorizeMiddleware<any>[] = [
urlVerification,
];
// deno-lint-ignore no-explicit-any
public postAuthorizeMiddleware: Middleware<any>[] = [ignoringSelfEvents];
#slashCommands: ((
body: SlackRequestBody
) => SlackMessageHandler<E, SlashCommand> | null)[] = [];
#events: ((
body: SlackRequestBody
) => SlackHandler<E, SlackEvent<string>> | null)[] = [];
#globalShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, GlobalShortcut> | null)[] = [];
#messageShorcuts: ((
body: SlackRequestBody
) => SlackHandler<E, MessageShortcut> | null)[] = [];
#blockActions: ((body: SlackRequestBody) => SlackHandler<
E,
// deno-lint-ignore no-explicit-any
BlockAction<any>
> | null)[] = [];
#blockSuggestions: ((
body: SlackRequestBody
) => SlackOptionsHandler<E, BlockSuggestion> | null)[] = [];
#viewSubmissions: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewSubmission> | null)[] = [];
#viewClosed: ((
body: SlackRequestBody
) => SlackViewHandler<E, ViewClosed> | null)[] = [];
constructor(options: SlackAppOptions<E>) {
if (
options.env.SLACK_BOT_TOKEN === undefined &&
(options.authorize === undefined ||
options.authorize === singleTeamAuthorize)
) {
throw new ConfigError(
"When you don't pass env.SLACK_BOT_TOKEN, your own authorize function, which supplies a valid token to use, needs to be passed instead."
);
}
this.env = options.env;
this.client = new SlackAPIClient(options.env.SLACK_BOT_TOKEN, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
this.appLevelToken = options.env.SLACK_APP_TOKEN;
this.socketMode = options.socketMode ?? this.appLevelToken !== undefined;
if (this.socketMode) {
this.signingSecret = "";
} else {
if (!this.env.SLACK_SIGNING_SECRET) {
throw new ConfigError(
"env.SLACK_SIGNING_SECRET is required to run your app on edge functions!"
);
}
this.signingSecret = this.env.SLACK_SIGNING_SECRET;
}
this.authorize = options.authorize ?? singleTeamAuthorize;
this.routes = { events: options.routes?.events };
}
beforeAuthorize(middleware: PreAuthorizeMiddleware<E>): SlackApp<E> {
this.preAuthorizeMiddleware.push(middleware);
return this;
}
middleware(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
use(middleware: Middleware<E>): SlackApp<E> {
return this.afterAuthorize(middleware);
}
afterAuthorize(middleware: Middleware<E>): SlackApp<E> {
this.postAuthorizeMiddleware.push(middleware);
return this;
}
command(
pattern: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<MessageAckResponse>,
lazy: (
req: SlackRequestWithRespond<E, SlashCommand>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackMessageHandler<E, SlashCommand> = { ack, lazy };
this.#slashCommands.push((body) => {
if (body.type || !body.command) {
return null;
}
if (typeof pattern === "string" && body.command === pattern) {
return handler;
} else if (
typeof pattern === "object" &&
pattern instanceof RegExp &&
body.command.match(pattern)
) {
return handler;
}
return null;
});
return this;
}
event<Type extends string>(
event: Type,
lazy: (req: EventRequest<E, Type>) => Promise<void>
): SlackApp<E> {
this.#events.push((body) => {
if (body.type !== PayloadType.EventsAPI || !body.event) {
return null;
}
if (body.event.type === event) {
// deno-lint-ignore require-await
return { ack: async () => "", lazy };
}
return null;
});
return this;
}
anyMessage(lazy: MessageEventHandler<E>): SlackApp<E> {
return this.message(undefined, lazy);
}
message(
pattern: MessageEventPattern,
lazy: MessageEventHandler<E>
): SlackApp<E> {
this.#events.push((body) => {
if (
body.type !== PayloadType.EventsAPI ||
!body.event ||
body.event.type !== "message"
) {
return null;
}
if (isPostedMessageEvent(body.event)) {
let matched = true;
if (pattern !== undefined) {
if (typeof pattern === "string") {
matched = body.event.text!.includes(pattern);
}
if (typeof pattern === "object") {
matched = body.event.text!.match(pattern) !== null;
}
}
if (matched) {
// deno-lint-ignore require-await
return { ack: async (_: EventRequest<E, "message">) => "", lazy };
}
}
return null;
});
return this;
}
shortcut(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req:
| SlackRequest<E, GlobalShortcut>
| SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.globalShortcut(callbackId, ack, lazy).messageShortcut(
callbackId,
ack,
lazy
);
}
globalShortcut(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, GlobalShortcut>) => Promise<AckResponse>,
lazy: (
req: SlackRequest<E, GlobalShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, GlobalShortcut> = { ack, lazy };
this.#globalShorcuts.push((body) => {
if (body.type !== PayloadType.GlobalShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
messageShortcut(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithRespond<E, MessageShortcut>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, MessageShortcut> = { ack, lazy };
this.#messageShorcuts.push((body) => {
if (body.type !== PayloadType.MessageShortcut || !body.callback_id) {
return null;
}
if (typeof callbackId === "string" && body.callback_id === callbackId) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
action<
T extends BlockElementTypes,
A extends BlockAction<BlockElementAction<T>> = BlockAction<
BlockElementAction<T>
>
>(
constraints:
| StringOrRegExp
| { type: T; block_id?: string; action_id: string },
ack: (req: SlackRequestWithOptionalRespond<E, A>) => Promise<AckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, A>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackHandler<E, A> = { ack, lazy };
this.#blockActions.push((body) => {
if (
body.type !== PayloadType.BlockAction ||
!body.actions ||
!body.actions[0]
) {
return null;
}
const action = body.actions[0];
if (typeof constraints === "string" && action.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (action.action_id.match(constraints)) {
return handler;
}
} else if (constraints.type) {
if (action.type === constraints.type) {
if (action.action_id === constraints.action_id) {
if (
constraints.block_id &&
action.block_id !== constraints.block_id
) {
return null;
}
return handler;
}
}
}
}
return null;
});
return this;
}
options(
constraints: StringOrRegExp | { block_id?: string; action_id: string },
ack: (req: SlackRequest<E, BlockSuggestion>) => Promise<OptionsAckResponse>
): SlackApp<E> {
// Note that block_suggestion response must be done within 3 seconds.
// So, we don't support the lazy handler for it.
const handler: SlackOptionsHandler<E, BlockSuggestion> = { ack };
this.#blockSuggestions.push((body) => {
if (body.type !== PayloadType.BlockSuggestion || !body.action_id) {
return null;
}
if (typeof constraints === "string" && body.action_id === constraints) {
return handler;
} else if (typeof constraints === "object") {
if (constraints instanceof RegExp) {
if (body.action_id.match(constraints)) {
return handler;
}
} else {
if (body.action_id === constraints.action_id) {
if (body.block_id && body.block_id !== constraints.block_id) {
return null;
}
return handler;
}
}
}
return null;
});
return this;
}
view(
callbackId: StringOrRegExp,
ack: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<ViewAckResponse>,
lazy: (
req:
| SlackRequestWithOptionalRespond<E, ViewSubmission>
| SlackRequest<E, ViewClosed>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
return this.viewSubmission(callbackId, ack, lazy).viewClosed(
callbackId,
ack,
lazy
);
}
viewSubmission(
callbackId: StringOrRegExp,
ack: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<ViewAckResponse>,
lazy: (
req: SlackRequestWithOptionalRespond<E, ViewSubmission>
) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewSubmission> = { ack, lazy };
this.#viewSubmissions.push((body) => {
if (body.type !== PayloadType.ViewSubmission || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
viewClosed(
callbackId: StringOrRegExp,
ack: (req: SlackRequest<E, ViewClosed>) => Promise<ViewAckResponse>,
lazy: (req: SlackRequest<E, ViewClosed>) => Promise<void> = noopLazyListener
): SlackApp<E> {
const handler: SlackViewHandler<E, ViewClosed> = { ack, lazy };
this.#viewClosed.push((body) => {
if (body.type !== PayloadType.ViewClosed || !body.view) {
return null;
}
if (
typeof callbackId === "string" &&
body.view.callback_id === callbackId
) {
return handler;
} else if (
typeof callbackId === "object" &&
callbackId instanceof RegExp &&
body.view.callback_id.match(callbackId)
) {
return handler;
}
return null;
});
return this;
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
return await this.handleEventRequest(request, ctx);
}
async connect(): Promise<void> {
if (!this.socketMode) {
throw new ConfigError(
"Both env.SLACK_APP_TOKEN and socketMode: true are required to start a Socket Mode connection!"
);
}
this.socketModeClient = new SocketModeClient(this);
await this.socketModeClient.connect();
}
async disconnect(): Promise<void> {
if (this.socketModeClient) {
await this.socketModeClient.disconnect();
}
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
// If the routes.events is missing, any URLs can work for handing requests from Slack
if (this.routes.events) {
const { pathname } = new URL(request.url);
if (pathname !== this.routes.events) {
return new Response("Not found", { status: 404 });
}
}
// To avoid the following warning by Cloudflware, parse the body as Blob first
// Called .text() on an HTTP body which does not appear to be text ..
const blobRequestBody = await request.blob();
// We can safely assume the incoming request body is always text data
const rawBody: string = await blobRequestBody.text();
// For Request URL verification
if (rawBody.includes("ssl_check=")) {
// Slack does not send the x-slack-signature header for this pattern.
// Thus, we need to check the pattern before verifying a request.
const bodyParams = new URLSearchParams(rawBody);
if (bodyParams.get("ssl_check") === "1" && bodyParams.get("token")) {
return new Response("", { status: 200 });
}
}
// Verify the request headers and body
const isRequestSignatureVerified =
this.socketMode ||
(await verifySlackRequest(this.signingSecret, request.headers, rawBody));
if (isRequestSignatureVerified) {
// deno-lint-ignore no-explicit-any
const body: Record<string, any> = await parseRequestBody(
request.headers,
rawBody
);
let retryNum: number | undefined = undefined;
try {
const retryNumHeader = request.headers.get("x-slack-retry-num");
if (retryNumHeader) {
retryNum = Number.parseInt(retryNumHeader);
} else if (this.socketMode && body.retry_attempt) {
retryNum = Number.parseInt(body.retry_attempt);
}
// deno-lint-ignore no-unused-vars
} catch (e) {
// Ignore an exception here
}
const retryReason =
request.headers.get("x-slack-retry-reason") ?? body.retry_reason;
const preAuthorizeRequest: PreAuthorizeSlackMiddlwareRequest<E> = {
body,
rawBody,
retryNum,
retryReason,
context: builtBaseContext(body),
env: this.env,
headers: request.headers,
};
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received request body ***\n ${prettyPrint(body)}`);
}
for (const middlware of this.preAuthorizeMiddleware) {
const response = await middlware(preAuthorizeRequest);
if (response) {
return toCompleteResponse(response);
}
}
const authorizeResult: AuthorizeResult = await this.authorize(
preAuthorizeRequest
);
const authorizedContext: SlackAppContext = {
...preAuthorizeRequest.context,
authorizeResult,
client: new SlackAPIClient(authorizeResult.botToken, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
}),
botToken: authorizeResult.botToken,
botId: authorizeResult.botId,
botUserId: authorizeResult.botUserId,
userToken: authorizeResult.userToken,
};
if (authorizedContext.channelId) {
const context = authorizedContext as SlackAppContextWithChannelId;
const client = new SlackAPIClient(context.botToken);
context.say = async (params) =>
await client.chat.postMessage({
channel: context.channelId,
...params,
});
}
if (authorizedContext.responseUrl) {
const responseUrl = authorizedContext.responseUrl;
// deno-lint-ignore require-await
(authorizedContext as SlackAppContextWithRespond).respond = async (
params
) => {
return new ResponseUrlSender(responseUrl).call(params);
};
}
const baseRequest: SlackMiddlwareRequest<E> = {
...preAuthorizeRequest,
context: authorizedContext,
};
for (const middlware of this.postAuthorizeMiddleware) {
const response = await middlware(baseRequest);
if (response) {
return toCompleteResponse(response);
}
}
const payload = body as SlackRequestBody;
if (body.type === PayloadType.EventsAPI) {
// Events API
const slackRequest: SlackRequest<E, SlackEvent<string>> = {
payload: body.event,
...baseRequest,
};
for (const matcher of this.#events) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (!body.type && body.command) {
// Slash commands
const slackRequest: SlackRequest<E, SlashCommand> = {
payload: body as SlashCommand,
...baseRequest,
};
for (const matcher of this.#slashCommands) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.GlobalShortcut) {
// Global shortcuts
const slackRequest: SlackRequest<E, GlobalShortcut> = {
payload: body as GlobalShortcut,
...baseRequest,
};
for (const matcher of this.#globalShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.MessageShortcut) {
// Message shortcuts
const slackRequest: SlackRequest<E, MessageShortcut> = {
payload: body as MessageShortcut,
...baseRequest,
};
for (const matcher of this.#messageShorcuts) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockAction) {
// Block actions
// deno-lint-ignore no-explicit-any
const slackRequest: SlackRequest<E, BlockAction<any>> = {
// deno-lint-ignore no-explicit-any
payload: body as BlockAction<any>,
...baseRequest,
};
for (const matcher of this.#blockActions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.BlockSuggestion) {
// Block suggestions
const slackRequest: SlackRequest<E, BlockSuggestion> = {
payload: body as BlockSuggestion,
...baseRequest,
};
for (const matcher of this.#blockSuggestions) {
const handler = matcher(payload);
if (handler) {
// Note that the only way to respond to a block_suggestion request
// is to send an HTTP response with options/option_groups.
// Thus, we don't support lazy handlers for this pattern.
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewSubmission) {
// View submissions
const slackRequest: SlackRequest<E, ViewSubmission> = {
payload: body as ViewSubmission,
...baseRequest,
};
for (const matcher of this.#viewSubmissions) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
} else if (body.type === PayloadType.ViewClosed) {
// View closed
const slackRequest: SlackRequest<E, ViewClosed> = {
payload: body as ViewClosed,
...baseRequest,
};
for (const matcher of this.#viewClosed) {
const handler = matcher(payload);
if (handler) {
ctx.waitUntil(handler.lazy(slackRequest));
const slackResponse = await handler.ack(slackRequest);
if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {
console.log(
`*** Slack response ***\n${prettyPrint(slackResponse)}`
);
}
return toCompleteResponse(slackResponse);
}
}
}
// TODO: Add code suggestion here
console.log(
`*** No listener found ***\n${JSON.stringify(baseRequest.body)}`
);
return new Response("No listener found", { status: 404 });
}
return new Response("Invalid signature", { status: 401 });
}
}
export type StringOrRegExp = string | RegExp;
export type EventRequest<E extends SlackAppEnv, T> = Extract<
AnySlackEventWithChannelId,
{ type: T }
> extends never
? SlackRequest<E, Extract<AnySlackEvent, { type: T }>>
: SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { type: T }>
>;
export type MessageEventPattern = string | RegExp | undefined;
export type MessageEventRequest<
E extends SlackAppEnv,
ST extends string | undefined
> = SlackRequestWithChannelId<
E,
Extract<AnySlackEventWithChannelId, { subtype: ST }>
>;
export type MessageEventSubtypes =
| undefined
| "bot_message"
| "thread_broadcast"
| "file_share";
export type MessageEventHandler<E extends SlackAppEnv> = (
req: MessageEventRequest<E, MessageEventSubtypes>
) => Promise<void>;
export const noopLazyListener = async () => {};
|
src/app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.9150912165641785
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n}\nexport class SlackOAuthApp<E extends SlackOAuthEnv> extends SlackApp<E> {\n public env: E;\n public installationStore: InstallationStore<E>;\n public stateStore: StateStore;\n public oauth: {\n stateCookieName?: string;\n beforeInstallation?: BeforeInstallation;\n afterInstallation?: AfterInstallation;",
"score": 0.9082542657852173
},
{
"filename": "src/socket-mode/socket-mode-client.ts",
"retrieved_chunk": "import { SlackAPIClient, isDebugLogEnabled } from \"slack-web-api-client\";\nimport { SlackApp } from \"../app\";\nimport { ConfigError, SocketModeError } from \"../errors\";\nimport { ExecutionContext } from \"../execution-context\";\nimport { SlackSocketModeAppEnv } from \"../app-env\";\n// TODO: Implement proper reconnection logic\n// TODO: Add connection monitor like 1st party SDKs do\n// TODO: Add Bun support (the runtime does not work well with Socket Mode)\nexport class SocketModeClient {\n public app: SlackApp<SlackSocketModeAppEnv>;",
"score": 0.8930954933166504
},
{
"filename": "src/oauth-app.ts",
"retrieved_chunk": " };\n public routes: {\n events: string;\n oauth: { start: string; callback: string };\n oidc?: { start: string; callback: string };\n };\n constructor(options: SlackOAuthAppOptions<E>) {\n super({\n env: options.env,\n authorize: options.installationStore.toAuthorize(),",
"score": 0.8871853351593018
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": "export interface SlackLoggingLevel {\n SLACK_LOGGING_LEVEL?: \"DEBUG\" | \"INFO\" | \"WARN\" | \"ERROR\";\n}\nexport type SlackAppEnv = SlackLoggingLevel & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN?: string;\n};\nexport type SlackEdgeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET: string;",
"score": 0.8828305006027222
}
] |
typescript
|
: SocketModeClient | undefined;
|
import { SlackAPIClient, isDebugLogEnabled } from "slack-web-api-client";
import { SlackApp } from "../app";
import { ConfigError, SocketModeError } from "../errors";
import { ExecutionContext } from "../execution-context";
import { SlackSocketModeAppEnv } from "../app-env";
// TODO: Implement proper reconnection logic
// TODO: Add connection monitor like 1st party SDKs do
// TODO: Add Bun support (the runtime does not work well with Socket Mode)
export class SocketModeClient {
public app: SlackApp<SlackSocketModeAppEnv>;
public appLevelToken: string;
public ws: WebSocket | undefined;
constructor(
// deno-lint-ignore no-explicit-any
app: SlackApp<any>
) {
if (!app.socketMode) {
throw new ConfigError(
"socketMode: true must be set for running with Socket Mode"
);
}
if (!app.appLevelToken) {
throw new ConfigError(
"appLevelToken must be set for running with Socket Mode"
);
}
this.app = app as SlackApp<SlackSocketModeAppEnv>;
this.appLevelToken = app.appLevelToken;
console.warn(
"WARNING: The Socket Mode support provided by slack-edge is still experimental and is not designed to handle reconnections for production-grade applications. It is recommended to use this mode only for local development and testing purposes."
);
}
async connect() {
const client = new SlackAPIClient(this.appLevelToken);
try {
const newConnection = await client.apps.connections.open();
this.ws = new WebSocket(newConnection.url!);
} catch (e) {
throw new SocketModeError(
`Failed to establish a new WSS connection: ${e}`
);
}
if (this.ws) {
const ws = this.ws;
// deno-lint-ignore require-await
ws.onopen = async (ev) => {
// TODO: make this customizable
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(
`Now the Socket Mode client is connected to Slack: ${JSON.stringify(
ev
)}`
);
}
};
// deno-lint-ignore require-await
ws.onclose = async (ev) => {
// TODO: make this customizable
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(
`The Socket Mode client is disconnected from Slack: ${JSON.stringify(
ev
)}`
);
}
};
// deno-lint-ignore require-await
ws.onerror = async (e) => {
// TODO: make this customizable
console.error(
`An error was thrown by the Socket Mode connection: ${e}`
);
};
const app = this.app;
ws.onmessage = async (ev) => {
try {
if (
ev.data &&
typeof ev.data === "string" &&
ev.data.startsWith("{")
) {
const data = JSON.parse(ev.data);
if (data.type === "hello") {
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received hello data ***\n ${ev.data}`);
}
return;
}
const payload = JSON.stringify(data.payload);
console.log(payload);
const request: Request = new Request(ws.url, {
method: "POST",
headers: new Headers({ "content-type": "application/json" }),
body: new Blob([payload]).stream(),
});
const context: ExecutionContext = {
// deno-lint-ignore require-await
waitUntil: async (promise) => {
promise
.then(
|
(res) => {
|
console.info(`Completed a lazy listener execution: ${res}`);
})
.catch((err) => {
console.error(`Failed to run a lazy listener: ${err}`);
});
},
};
const response = await app.run(request, context);
// deno-lint-ignore no-explicit-any
let ack: any = { envelope_id: data.envelope_id };
if (response.body) {
const contentType = response.headers.get("Content-Type");
if (contentType && contentType.startsWith("text/plain")) {
const text = await response.text();
ack = { envelope_id: data.envelope_id, payload: { text } };
} else {
const json = await response.json();
ack = { envelope_id: data.envelope_id, payload: { ...json } };
}
}
ws.send(JSON.stringify(ack));
} else {
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received non-JSON data ***\n ${ev.data}`);
}
}
} catch (e) {
console.error(`Failed to handle a WebSocke message: ${e}`);
}
};
}
}
// deno-lint-ignore require-await
async disconnect(): Promise<void> {
if (this.ws) {
this.ws.close();
this.ws = undefined;
}
}
}
|
src/socket-mode/socket-mode-client.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/request/request-parser.ts",
"retrieved_chunk": " ) {\n return JSON.parse(requestBody);\n }\n const params = new URLSearchParams(requestBody);\n if (params.has(\"payload\")) {\n const payload = params.get(\"payload\")!;\n return JSON.parse(payload);\n }\n // deno-lint-ignore no-explicit-any\n const formBody: any = {};",
"score": 0.8217777013778687
},
{
"filename": "src/app.ts",
"retrieved_chunk": " const blobRequestBody = await request.blob();\n // We can safely assume the incoming request body is always text data\n const rawBody: string = await blobRequestBody.text();\n // For Request URL verification\n if (rawBody.includes(\"ssl_check=\")) {\n // Slack does not send the x-slack-signature header for this pattern.\n // Thus, we need to check the pattern before verifying a request.\n const bodyParams = new URLSearchParams(rawBody);\n if (bodyParams.get(\"ssl_check\") === \"1\" && bodyParams.get(\"token\")) {\n return new Response(\"\", { status: 200 });",
"score": 0.8140603303909302
},
{
"filename": "src/app.ts",
"retrieved_chunk": " const client = new SlackAPIClient(context.botToken);\n context.say = async (params) =>\n await client.chat.postMessage({\n channel: context.channelId,\n ...params,\n });\n }\n if (authorizedContext.responseUrl) {\n const responseUrl = authorizedContext.responseUrl;\n // deno-lint-ignore require-await",
"score": 0.8123206496238708
},
{
"filename": "src/app.ts",
"retrieved_chunk": " payload: body.event,\n ...baseRequest,\n };\n for (const matcher of this.#events) {\n const handler = matcher(payload);\n if (handler) {\n ctx.waitUntil(handler.lazy(slackRequest));\n const slackResponse = await handler.ack(slackRequest);\n if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {\n console.log(",
"score": 0.8104240894317627
},
{
"filename": "src/app.ts",
"retrieved_chunk": " }\n }\n // Verify the request headers and body\n const isRequestSignatureVerified =\n this.socketMode ||\n (await verifySlackRequest(this.signingSecret, request.headers, rawBody));\n if (isRequestSignatureVerified) {\n // deno-lint-ignore no-explicit-any\n const body: Record<string, any> = await parseRequestBody(\n request.headers,",
"score": 0.8097420930862427
}
] |
typescript
|
(res) => {
|
import { SlackAPIClient, isDebugLogEnabled } from "slack-web-api-client";
import { SlackApp } from "../app";
import { ConfigError, SocketModeError } from "../errors";
import { ExecutionContext } from "../execution-context";
import { SlackSocketModeAppEnv } from "../app-env";
// TODO: Implement proper reconnection logic
// TODO: Add connection monitor like 1st party SDKs do
// TODO: Add Bun support (the runtime does not work well with Socket Mode)
export class SocketModeClient {
public app: SlackApp<SlackSocketModeAppEnv>;
public appLevelToken: string;
public ws: WebSocket | undefined;
constructor(
// deno-lint-ignore no-explicit-any
app: SlackApp<any>
) {
if (!app.socketMode) {
throw new ConfigError(
"socketMode: true must be set for running with Socket Mode"
);
}
if (!app.appLevelToken) {
throw new ConfigError(
"appLevelToken must be set for running with Socket Mode"
);
}
this.app = app as SlackApp<SlackSocketModeAppEnv>;
this.appLevelToken = app.appLevelToken;
console.warn(
"WARNING: The Socket Mode support provided by slack-edge is still experimental and is not designed to handle reconnections for production-grade applications. It is recommended to use this mode only for local development and testing purposes."
);
}
async connect() {
const client = new SlackAPIClient(this.appLevelToken);
try {
const newConnection = await client.apps.connections.open();
this.ws = new WebSocket(newConnection.url!);
} catch (e) {
throw new SocketModeError(
`Failed to establish a new WSS connection: ${e}`
);
}
if (this.ws) {
const ws = this.ws;
// deno-lint-ignore require-await
ws.onopen = async (ev) => {
// TODO: make this customizable
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(
`Now the Socket Mode client is connected to Slack: ${JSON.stringify(
ev
)}`
);
}
};
// deno-lint-ignore require-await
ws.onclose = async (ev) => {
// TODO: make this customizable
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(
`The Socket Mode client is disconnected from Slack: ${JSON.stringify(
ev
)}`
);
}
};
// deno-lint-ignore require-await
ws.onerror = async (e) => {
// TODO: make this customizable
console.error(
`An error was thrown by the Socket Mode connection: ${e}`
);
};
const app = this.app;
ws.onmessage = async (ev) => {
try {
if (
ev.data &&
typeof ev.data === "string" &&
ev.data.startsWith("{")
) {
const data = JSON.parse(ev.data);
if (data.type === "hello") {
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received hello data ***\n ${ev.data}`);
}
return;
}
const payload = JSON.stringify(data.payload);
console.log(payload);
const request: Request = new Request(ws.url, {
method: "POST",
headers: new Headers({ "content-type": "application/json" }),
body: new Blob([payload]).stream(),
});
const context: ExecutionContext = {
// deno-lint-ignore require-await
waitUntil: async
|
(promise) => {
|
promise
.then((res) => {
console.info(`Completed a lazy listener execution: ${res}`);
})
.catch((err) => {
console.error(`Failed to run a lazy listener: ${err}`);
});
},
};
const response = await app.run(request, context);
// deno-lint-ignore no-explicit-any
let ack: any = { envelope_id: data.envelope_id };
if (response.body) {
const contentType = response.headers.get("Content-Type");
if (contentType && contentType.startsWith("text/plain")) {
const text = await response.text();
ack = { envelope_id: data.envelope_id, payload: { text } };
} else {
const json = await response.json();
ack = { envelope_id: data.envelope_id, payload: { ...json } };
}
}
ws.send(JSON.stringify(ack));
} else {
if (isDebugLogEnabled(app.env.SLACK_LOGGING_LEVEL)) {
console.log(`*** Received non-JSON data ***\n ${ev.data}`);
}
}
} catch (e) {
console.error(`Failed to handle a WebSocke message: ${e}`);
}
};
}
}
// deno-lint-ignore require-await
async disconnect(): Promise<void> {
if (this.ws) {
this.ws.close();
this.ws = undefined;
}
}
}
|
src/socket-mode/socket-mode-client.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/app.ts",
"retrieved_chunk": " payload: body.event,\n ...baseRequest,\n };\n for (const matcher of this.#events) {\n const handler = matcher(payload);\n if (handler) {\n ctx.waitUntil(handler.lazy(slackRequest));\n const slackResponse = await handler.ack(slackRequest);\n if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {\n console.log(",
"score": 0.833712637424469
},
{
"filename": "src/request/request-parser.ts",
"retrieved_chunk": " ) {\n return JSON.parse(requestBody);\n }\n const params = new URLSearchParams(requestBody);\n if (params.has(\"payload\")) {\n const payload = params.get(\"payload\")!;\n return JSON.parse(payload);\n }\n // deno-lint-ignore no-explicit-any\n const formBody: any = {};",
"score": 0.826524019241333
},
{
"filename": "src/app.ts",
"retrieved_chunk": " const client = new SlackAPIClient(context.botToken);\n context.say = async (params) =>\n await client.chat.postMessage({\n channel: context.channelId,\n ...params,\n });\n }\n if (authorizedContext.responseUrl) {\n const responseUrl = authorizedContext.responseUrl;\n // deno-lint-ignore require-await",
"score": 0.8210071921348572
},
{
"filename": "src/app.ts",
"retrieved_chunk": " }\n }\n // Verify the request headers and body\n const isRequestSignatureVerified =\n this.socketMode ||\n (await verifySlackRequest(this.signingSecret, request.headers, rawBody));\n if (isRequestSignatureVerified) {\n // deno-lint-ignore no-explicit-any\n const body: Record<string, any> = await parseRequestBody(\n request.headers,",
"score": 0.8198764324188232
},
{
"filename": "src/app.ts",
"retrieved_chunk": " };\n for (const matcher of this.#globalShorcuts) {\n const handler = matcher(payload);\n if (handler) {\n ctx.waitUntil(handler.lazy(slackRequest));\n const slackResponse = await handler.ack(slackRequest);\n if (isDebugLogEnabled(this.env.SLACK_LOGGING_LEVEL)) {\n console.log(\n `*** Slack response ***\\n${prettyPrint(slackResponse)}`\n );",
"score": 0.8189405202865601
}
] |
typescript
|
(promise) => {
|
import { ExecutionContext, NoopExecutionContext } from "./execution-context";
import { SlackApp } from "./app";
import { SlackOAuthEnv } from "./app-env";
import { InstallationStore } from "./oauth/installation-store";
import { NoStorageStateStore, StateStore } from "./oauth/state-store";
import {
renderCompletionPage,
renderStartPage,
} from "./oauth/oauth-page-renderer";
import { generateAuthorizeUrl } from "./oauth/authorize-url-generator";
import { parse as parseCookie } from "./cookie";
import {
SlackAPIClient,
OAuthV2AccessResponse,
OpenIDConnectTokenResponse,
} from "slack-web-api-client";
import { toInstallation } from "./oauth/installation";
import {
AfterInstallation,
BeforeInstallation,
OnFailure,
OnStateValidationError,
defaultOnFailure,
defaultOnStateValidationError,
} from "./oauth/callback";
import {
OpenIDConnectCallback,
defaultOpenIDConnectCallback,
} from "./oidc/callback";
import { generateOIDCAuthorizeUrl } from "./oidc/authorize-url-generator";
import {
InstallationError,
MissingCode,
CompletionPageError,
InstallationStoreError,
OpenIDConnectError,
} from "./oauth/error-codes";
export interface SlackOAuthAppOptions<E extends SlackOAuthEnv> {
env: E;
installationStore: InstallationStore<E>;
stateStore?: StateStore;
oauth?: {
stateCookieName?: string;
beforeInstallation?: BeforeInstallation;
afterInstallation?: AfterInstallation;
onFailure?: OnFailure;
onStateValidationError?: OnStateValidationError;
redirectUri?: string;
};
oidc?: {
stateCookieName?: string;
callback: OpenIDConnectCallback;
onFailure?: OnFailure;
onStateValidationError?: OnStateValidationError;
redirectUri?: string;
};
routes?: {
events: string;
oauth: { start: string; callback: string };
oidc?: { start: string; callback: string };
};
}
|
export class SlackOAuthApp<E extends SlackOAuthEnv> extends SlackApp<E> {
|
public env: E;
public installationStore: InstallationStore<E>;
public stateStore: StateStore;
public oauth: {
stateCookieName?: string;
beforeInstallation?: BeforeInstallation;
afterInstallation?: AfterInstallation;
onFailure: OnFailure;
onStateValidationError: OnStateValidationError;
redirectUri?: string;
};
public oidc?: {
stateCookieName?: string;
callback: OpenIDConnectCallback;
onFailure: OnFailure;
onStateValidationError: OnStateValidationError;
redirectUri?: string;
};
public routes: {
events: string;
oauth: { start: string; callback: string };
oidc?: { start: string; callback: string };
};
constructor(options: SlackOAuthAppOptions<E>) {
super({
env: options.env,
authorize: options.installationStore.toAuthorize(),
routes: { events: options.routes?.events ?? "/slack/events" },
});
this.env = options.env;
this.installationStore = options.installationStore;
this.stateStore = options.stateStore ?? new NoStorageStateStore();
this.oauth = {
stateCookieName:
options.oauth?.stateCookieName ?? "slack-app-oauth-state",
onFailure: options.oauth?.onFailure ?? defaultOnFailure,
onStateValidationError:
options.oauth?.onStateValidationError ?? defaultOnStateValidationError,
redirectUri: options.oauth?.redirectUri ?? this.env.SLACK_REDIRECT_URI,
};
if (options.oidc) {
this.oidc = {
stateCookieName: options.oidc.stateCookieName ?? "slack-app-oidc-state",
onFailure: options.oidc.onFailure ?? defaultOnFailure,
onStateValidationError:
options.oidc.onStateValidationError ?? defaultOnStateValidationError,
callback: defaultOpenIDConnectCallback(this.env),
redirectUri:
options.oidc.redirectUri ?? this.env.SLACK_OIDC_REDIRECT_URI,
};
} else {
this.oidc = undefined;
}
this.routes = options.routes
? options.routes
: {
events: "/slack/events",
oauth: {
start: "/slack/install",
callback: "/slack/oauth_redirect",
},
oidc: {
start: "/slack/login",
callback: "/slack/login/callback",
},
};
}
async run(
request: Request,
ctx: ExecutionContext = new NoopExecutionContext()
): Promise<Response> {
const url = new URL(request.url);
if (request.method === "GET") {
if (url.pathname === this.routes.oauth.start) {
return await this.handleOAuthStartRequest(request);
} else if (url.pathname === this.routes.oauth.callback) {
return await this.handleOAuthCallbackRequest(request);
}
if (this.routes.oidc) {
if (url.pathname === this.routes.oidc.start) {
return await this.handleOIDCStartRequest(request);
} else if (url.pathname === this.routes.oidc.callback) {
return await this.handleOIDCCallbackRequest(request);
}
}
} else if (request.method === "POST") {
if (url.pathname === this.routes.events) {
return await this.handleEventRequest(request, ctx);
}
}
return new Response("Not found", { status: 404 });
}
async handleEventRequest(
request: Request,
ctx: ExecutionContext
): Promise<Response> {
return await super.handleEventRequest(request, ctx);
}
// deno-lint-ignore no-unused-vars
async handleOAuthStartRequest(request: Request): Promise<Response> {
const stateValue = await this.stateStore.issueNewState();
const authorizeUrl = generateAuthorizeUrl(stateValue, this.env);
return new Response(renderStartPage(authorizeUrl), {
status: 302,
headers: {
Location: authorizeUrl,
"Set-Cookie": `${this.oauth.stateCookieName}=${stateValue}; Secure; HttpOnly; Path=/; Max-Age=300`,
"Content-Type": "text/html; charset=utf-8",
},
});
}
async handleOAuthCallbackRequest(request: Request): Promise<Response> {
// State parameter validation
await this.#validateStateParameter(
request,
this.routes.oauth.start,
this.oauth.stateCookieName!
);
const { searchParams } = new URL(request.url);
const code = searchParams.get("code");
if (!code) {
return await this.oauth.onFailure(
this.routes.oauth.start,
MissingCode,
request
);
}
const client = new SlackAPIClient(undefined, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
let oauthAccess: OAuthV2AccessResponse | undefined;
try {
// Execute the installation process
oauthAccess = await client.oauth.v2.access({
client_id: this.env.SLACK_CLIENT_ID,
client_secret: this.env.SLACK_CLIENT_SECRET,
redirect_uri: this.oauth.redirectUri,
code,
});
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
InstallationError,
request
);
}
try {
// Store the installation data on this app side
await this.installationStore.save(toInstallation(oauthAccess), request);
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
InstallationStoreError,
request
);
}
try {
// Build the completion page
const authTest = await client.auth.test({
token: oauthAccess.access_token,
});
const enterpriseUrl = authTest.url;
return new Response(
renderCompletionPage(
oauthAccess.app_id!,
oauthAccess.team?.id!,
oauthAccess.is_enterprise_install,
enterpriseUrl
),
{
status: 200,
headers: {
"Set-Cookie": `${this.oauth.stateCookieName}=deleted; Secure; HttpOnly; Path=/; Max-Age=0`,
"Content-Type": "text/html; charset=utf-8",
},
}
);
} catch (e) {
console.log(e);
return await this.oauth.onFailure(
this.routes.oauth.start,
CompletionPageError,
request
);
}
}
// deno-lint-ignore no-unused-vars
async handleOIDCStartRequest(request: Request): Promise<Response> {
if (!this.oidc) {
return new Response("Not found", { status: 404 });
}
const stateValue = await this.stateStore.issueNewState();
const authorizeUrl = generateOIDCAuthorizeUrl(stateValue, this.env);
return new Response(renderStartPage(authorizeUrl), {
status: 302,
headers: {
Location: authorizeUrl,
"Set-Cookie": `${this.oidc.stateCookieName}=${stateValue}; Secure; HttpOnly; Path=/; Max-Age=300`,
"Content-Type": "text/html; charset=utf-8",
},
});
}
async handleOIDCCallbackRequest(request: Request): Promise<Response> {
if (!this.oidc || !this.routes.oidc) {
return new Response("Not found", { status: 404 });
}
// State parameter validation
await this.#validateStateParameter(
request,
this.routes.oidc.start,
this.oidc.stateCookieName!
);
const { searchParams } = new URL(request.url);
const code = searchParams.get("code");
if (!code) {
return await this.oidc.onFailure(
this.routes.oidc.start,
MissingCode,
request
);
}
try {
const client = new SlackAPIClient(undefined, {
logLevel: this.env.SLACK_LOGGING_LEVEL,
});
const apiResponse: OpenIDConnectTokenResponse =
await client.openid.connect.token({
client_id: this.env.SLACK_CLIENT_ID,
client_secret: this.env.SLACK_CLIENT_SECRET,
redirect_uri: this.oidc.redirectUri,
code,
});
return await this.oidc.callback(apiResponse, request);
} catch (e) {
console.log(e);
return await this.oidc.onFailure(
this.routes.oidc.start,
OpenIDConnectError,
request
);
}
}
async #validateStateParameter(
request: Request,
startPath: string,
cookieName: string
) {
const { searchParams } = new URL(request.url);
const queryState = searchParams.get("state");
const cookie = parseCookie(request.headers.get("Cookie") || "");
const cookieState = cookie[cookieName];
if (
queryState !== cookieState ||
!(await this.stateStore.consume(queryState))
) {
if (startPath === this.routes.oauth.start) {
return await this.oauth.onStateValidationError(startPath, request);
} else if (
this.oidc &&
this.routes.oidc &&
startPath === this.routes.oidc.start
) {
return await this.oidc.onStateValidationError(startPath, request);
}
}
}
}
|
src/oauth-app.ts
|
seratch-slack-edge-c75c224
|
[
{
"filename": "src/app.ts",
"retrieved_chunk": "export interface SlackAppOptions<\n E extends SlackEdgeAppEnv | SlackSocketModeAppEnv\n> {\n env: E;\n authorize?: Authorize<E>;\n routes?: {\n events: string;\n };\n socketMode?: boolean;\n}",
"score": 0.8934139609336853
},
{
"filename": "src/app.ts",
"retrieved_chunk": "export class SlackApp<E extends SlackEdgeAppEnv | SlackSocketModeAppEnv> {\n public env: E;\n public client: SlackAPIClient;\n public authorize: Authorize<E>;\n public routes: { events: string | undefined };\n public signingSecret: string;\n public appLevelToken: string | undefined;\n public socketMode: boolean;\n public socketModeClient: SocketModeClient | undefined;\n // deno-lint-ignore no-explicit-any",
"score": 0.8931620121002197
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_OIDC_SCOPES?: string;\n SLACK_OIDC_REDIRECT_URI: string;\n};\nexport type SlackOAuthAndOIDCEnv = SlackOAuthEnv & SlackOIDCEnv;",
"score": 0.8745168447494507
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_TOKEN?: string;\n};\nexport type SlackSocketModeAppEnv = SlackAppEnv & {\n SLACK_SIGNING_SECRET?: string;\n SLACK_BOT_TOKEN?: string;\n SLACK_APP_TOKEN: string;\n};\nexport type SlackOAuthEnv = (SlackEdgeAppEnv | SlackSocketModeAppEnv) & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.8740291595458984
},
{
"filename": "src/app-env.ts",
"retrieved_chunk": " SLACK_BOT_SCOPES: string;\n SLACK_USER_SCOPES?: string;\n SLACK_REDIRECT_URI?: string;\n SLACK_OIDC_SCOPES?: string;\n SLACK_OIDC_REDIRECT_URI?: string;\n SLACK_USER_TOKEN_RESOLUTION?: \"installer\" | \"actor\";\n};\nexport type SlackOIDCEnv = SlackAppEnv & {\n SLACK_CLIENT_ID: string;\n SLACK_CLIENT_SECRET: string;",
"score": 0.8732839226722717
}
] |
typescript
|
export class SlackOAuthApp<E extends SlackOAuthEnv> extends SlackApp<E> {
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.