@dbos-inc/koa-serve 3.0.27-preview → 3.0.35-preview

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbos-inc/koa-serve",
-  "version": "3.0.27-preview",
+  "version": "3.0.35-preview",
   "description": "DBOS HTTP Package for serving workflows with Koa",
   "license": "MIT",
   "repository": {
@@ -30,7 +30,8 @@
     "typescript": "^5.3.3"
   },
   "peerDependencies": {
-    "@dbos-inc/dbos-sdk": "*"
+    "@dbos-inc/dbos-sdk": "*",
+    "@dbos-inc/knex-datasource": "*"
   },
   "dependencies": {
     "@koa/bodyparser": "5.0.0",

package/src/dboshttp.ts

@@ -150,7 +150,7 @@ export class DBOSHTTPBase implements DBOSLifecycleCallback {
 
   /** Parameter decorator indicating which source to use (URL, BODY, etc) for arg data */
   static argSource(source: ArgSources) {
-    return function (target: object, propertyKey: string | symbol, parameterIndex: number) {
+    return function (target: object, propertyKey: PropertyKey, parameterIndex: number) {
       const curParam = DBOS.associateParamWithInfo(
         DBOSHTTP,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
@@ -190,11 +190,11 @@ export class DBOSHTTPBase implements DBOSLifecycleCallback {
     }
   }
 
-  static argRequired(target: object, propertyKey: string | symbol, parameterIndex: number) {
+  static argRequired(target: object, propertyKey: PropertyKey, parameterIndex: number) {
     ArgRequired(target, propertyKey, parameterIndex);
   }
 
-  static argOptional(target: object, propertyKey: string | symbol, parameterIndex: number) {
+  static argOptional(target: object, propertyKey: PropertyKey, parameterIndex: number) {
     ArgOptional(target, propertyKey, parameterIndex);
   }
 

package/src/dboskoa.ts

@@ -72,6 +72,11 @@ function assertCurrentKoaContextStore(): DBOSKoaLocalCtx {
 }
 
 export class DBOSKoa extends DBOSHTTPBase {
+  constructor() {
+    super();
+    DBOS.registerLifecycleCallback(this);
+  }
+
   static get koaContext(): Koa.Context {
     return assertCurrentKoaContextStore().koaCtxt;
   }

package/tests/argsource.test.ts

@@ -23,7 +23,6 @@ describe('httpserver-argsource-tests', () => {
   });
 
   beforeEach(async () => {
-    DBOS.registerLifecycleCallback(dhttp);
     const _classes = [ArgTestEndpoints];
     await DBOS.launch();
     app = new Koa();

package/tests/auth.test.ts

@@ -29,7 +29,6 @@ describe('httpserver-defsec-tests', () => {
   });
 
   beforeEach(async () => {
-    DBOS.registerLifecycleCallback(dhttp);
     const _classes = [TestEndpointDefSec, SecondClass];
     await DBOS.launch();
     await DBOS.queryUserDB(`DROP TABLE IF EXISTS ${testTableName};`);

package/tests/basic.test.ts

@@ -50,7 +50,6 @@ describe('decoratorless-api-tests', () => {
 
   beforeEach(async () => {
     middlewareCounter = middlewareCounter2 = middlewareCounterG = 0;
-    DBOS.registerLifecycleCallback(dhttp);
     await DBOS.launch();
     DBOS.logRegisteredEndpoints();
     app = new Koa();

package/tests/cors.test.ts

@@ -20,7 +20,6 @@ describe('http-cors-tests', () => {
   });
 
   beforeEach(async () => {
-    DBOS.registerLifecycleCallback(dhttp);
     await DBOS.launch();
     app = new Koa();
     appRouter = new Router();

package/tests/endpoints.test.ts

@@ -40,7 +40,6 @@ describe('httpserver-tests', () => {
   });
 
   beforeEach(async () => {
-    DBOS.registerLifecycleCallback(dhttp);
     const _classes = [TestEndpoints];
     await DBOS.launch();
     await DBOS.queryUserDB(`DROP TABLE IF EXISTS ${testTableName};`);

package/tests/steps.test.ts

@@ -0,0 +1,79 @@
+import { DBOS } from '@dbos-inc/dbos-sdk';
+import Koa from 'koa';
+import Router from '@koa/router';
+import { DBOSKoa } from '../src';
+
+import request from 'supertest';
+
+const dhttp = new DBOSKoa();
+
+function customstep() {
+  return function decorator<This, Args extends unknown[], Return>(
+    target: object,
+    propertyKey: PropertyKey,
+    descriptor: TypedPropertyDescriptor<(this: This, ...args: Args) => Promise<Return>>,
+  ) {
+    if (!descriptor.value) {
+      throw Error('Use of decorator when original method is undefined');
+    }
+
+    descriptor.value = DBOS.registerStep(descriptor.value, {
+      name: String(propertyKey),
+      ctorOrProto: target,
+    });
+
+    return descriptor;
+  };
+}
+
+describe('registerstep', () => {
+  let app: Koa;
+  let appRouter: Router;
+
+  beforeAll(async () => {});
+
+  afterAll(async () => {});
+
+  beforeEach(async () => {
+    DBOS.setConfig({ name: 'koa-step-test' });
+    await DBOS.launch();
+    app = new Koa();
+    appRouter = new Router();
+    dhttp.registerWithApp(app, appRouter);
+  });
+
+  afterEach(async () => {
+    await DBOS.shutdown();
+  });
+
+  test('use-customstep-and-koa', async () => {
+    const u1 = await KnexKoa.insertOneWay('joe');
+    expect(u1.user).toBe('joe');
+    const u2 = await KnexKoa.insertTheOtherWay('jack');
+    expect(u2.user).toBe('jack');
+
+    const response1 = await request(app.callback()).get('/api/i1?user=john');
+    expect(response1.statusCode).toBe(200);
+    const response2 = await request(app.callback()).get('/api/i2?user=jeremy');
+    expect(response2.statusCode).toBe(200);
+    const response3 = await request(app.callback()).get('/api/i1');
+    expect(response3.statusCode).toBe(400);
+    const response4 = await request(app.callback()).get('/api/i2');
+    expect(response4.statusCode).toBe(400);
+  });
+});
+
+@DBOSKoa.defaultArgValidate
+class KnexKoa {
+  @customstep()
+  @dhttp.getApi('/api/i2')
+  static async insertTheOtherWay(user: string) {
+    return Promise.resolve({ user, now: Date.now() });
+  }
+
+  @dhttp.getApi('/api/i1')
+  @customstep()
+  static async insertOneWay(user: string) {
+    return Promise.resolve({ user, now: Date.now() });
+  }
+}

package/tests/test-helpers.ts

@@ -0,0 +1,13 @@
+import { Client } from 'pg';
+
+export async function ensureDB(client: Client, name: string) {
+  const results = await client.query('SELECT 1 FROM pg_database WHERE datname = $1', [name]);
+  if (results.rows.length === 0) {
+    await client.query(`CREATE DATABASE ${name}`);
+  }
+}
+
+export async function dropDB(client: Client, name: string, force: boolean = false) {
+  const withForce = force ? ' WITH (FORCE)' : '';
+  await client.query(`DROP DATABASE IF EXISTS ${name} ${withForce}`);
+}

package/tests/transactions.test.ts

@@ -0,0 +1,117 @@
+import { DBOS } from '@dbos-inc/dbos-sdk';
+import { Client, Pool } from 'pg';
+import { KnexDataSource } from '@dbos-inc/knex-datasource';
+import { dropDB, ensureDB } from './test-helpers';
+import Koa from 'koa';
+import Router from '@koa/router';
+import { DBOSKoa } from '../src';
+
+import request from 'supertest';
+
+const config = { client: 'pg', connection: { user: 'postgres', database: 'koa_knex_ds_test_userdb' } };
+const knexds = new KnexDataSource('app-db', config);
+
+const dhttp = new DBOSKoa();
+
+interface greetings {
+  name: string;
+  greet_count: number;
+}
+
+describe('KnexDataSource', () => {
+  const userDB = new Pool(config.connection);
+  let app: Koa;
+  let appRouter: Router;
+
+  beforeAll(async () => {
+    {
+      const client = new Client({ ...config.connection, database: 'postgres' });
+      try {
+        await client.connect();
+        await dropDB(client, 'koa_knex_ds_test', true);
+        await dropDB(client, 'koa_knex_ds_test_dbos_sys', true);
+        await dropDB(client, config.connection.database, true);
+        await ensureDB(client, config.connection.database);
+      } finally {
+        await client.end();
+      }
+    }
+
+    {
+      const client = await userDB.connect();
+      try {
+        await client.query(
+          'CREATE TABLE greetings(name text NOT NULL, greet_count integer DEFAULT 0, PRIMARY KEY(name))',
+        );
+      } finally {
+        client.release();
+      }
+    }
+
+    await KnexDataSource.initializeDBOSSchema(config);
+  });
+
+  afterAll(async () => {
+    await userDB.end();
+  });
+
+  beforeEach(async () => {
+    DBOS.setConfig({ name: 'koa-knex-ds-test' });
+    await DBOS.launch();
+    app = new Koa();
+    appRouter = new Router();
+    dhttp.registerWithApp(app, appRouter);
+  });
+
+  afterEach(async () => {
+    await DBOS.shutdown();
+  });
+
+  test('use-dstx-and-koa', async () => {
+    const u1 = await KnexKoa.insertOneWay('joe');
+    expect(u1.user).toBe('joe');
+    const u2 = await KnexKoa.insertTheOtherWay('jack');
+    expect(u2.user).toBe('jack');
+
+    const response1 = await request(app.callback()).get('/api/i1?user=john');
+    expect(response1.statusCode).toBe(200);
+    const response2 = await request(app.callback()).get('/api/i2?user=jeremy');
+    expect(response2.statusCode).toBe(200);
+    const response3 = await request(app.callback()).get('/api/i1');
+    expect(response3.statusCode).toBe(400);
+    const response4 = await request(app.callback()).get('/api/i2');
+    expect(response4.statusCode).toBe(400);
+  });
+});
+
+@DBOSKoa.defaultArgValidate
+class KnexKoa {
+  @knexds.transaction()
+  @dhttp.getApi('/api/i2')
+  static async insertTheOtherWay(user: string) {
+    const rows = await knexds
+      .client<greetings>('greetings')
+      .insert({ name: user, greet_count: 1 })
+      .onConflict('name')
+      .merge({ greet_count: knexds.client.raw('greetings.greet_count + 1') })
+      .returning('greet_count');
+
+    const row = rows.length > 0 ? rows[0] : undefined;
+
+    return { user, greet_count: row?.greet_count, now: Date.now() };
+  }
+
+  @dhttp.getApi('/api/i1')
+  @knexds.transaction()
+  static async insertOneWay(user: string) {
+    const rows = await knexds
+      .client<greetings>('greetings')
+      .insert({ name: user, greet_count: 1 })
+      .onConflict('name')
+      .merge({ greet_count: knexds.client.raw('greetings.greet_count + 1') })
+      .returning('greet_count');
+    const row = rows.length > 0 ? rows[0] : undefined;
+
+    return { user, greet_count: row?.greet_count, now: Date.now() };
+  }
+}