@teamkeel/functions-runtime 0.236.1 → 0.236.3

package/src/handleRequest.js

@@ -0,0 +1,52 @@
+const {
+  createJSONRPCErrorResponse,
+  createJSONRPCSuccessResponse,
+  JSONRPCErrorCode,
+} = require("json-rpc-2.0");
+
+// Generic handler function that is agnostic to runtime environment (local or lambda)
+// to execute a custom function based on the contents of a jsonrpc-2.0 payload object.
+// To read more about jsonrpc request and response shapes, please read https://www.jsonrpc.org/specification
+export async function handleRequest(request, config) {
+  const { createFunctionAPI, functions } = config;
+
+  if (!(request.method in functions)) {
+    return createJSONRPCErrorResponse(
+      request.id,
+      JSONRPCErrorCode.MethodNotFound,
+      `no corresponding function found for '${request.method}'`
+    );
+  }
+
+  try {
+    const result = await functions[request.method](
+      request.params,
+      createFunctionAPI()
+    );
+
+    if (result === undefined) {
+      // no result returned from custom function
+      return createJSONRPCErrorResponse(
+        request.id,
+        JSONRPCErrorCode.InternalError,
+        `no result returned from function '${request.method}'`
+      );
+    }
+
+    return createJSONRPCSuccessResponse(request.id, result);
+  } catch (e) {
+    let msg = "";
+
+    if (e instanceof Error) {
+      msg = e.message;
+    } else {
+      msg = JSON.stringify(e);
+    }
+
+    return createJSONRPCErrorResponse(
+      request.id,
+      JSONRPCErrorCode.InternalError,
+      msg
+    );
+  }
+}

package/src/handleRequest.test.js

@@ -0,0 +1,112 @@
+import { createJSONRPCRequest, JSONRPCErrorCode } from "json-rpc-2.0";
+import { handleRequest } from "./handleRequest";
+import { test, expect } from "vitest";
+
+test("when the custom function returns expected value", async () => {
+  const config = {
+    functions: {
+      createPost: async () => {
+        return {
+          title: "a post",
+          id: "abcde",
+        };
+      },
+    },
+    createFunctionAPI: () => {},
+  };
+
+  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
+
+  expect(await handleRequest(rpcReq, config)).toEqual({
+    id: "123",
+    jsonrpc: "2.0",
+    result: {
+      title: "a post",
+      id: "abcde",
+    },
+  });
+});
+
+test("when the custom function doesnt return a value", async () => {
+  const config = {
+    functions: {
+      createPost: async () => {},
+    },
+    createFunctionAPI: () => {},
+  };
+
+  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
+
+  expect(await handleRequest(rpcReq, config)).toEqual({
+    id: "123",
+    jsonrpc: "2.0",
+    error: {
+      code: JSONRPCErrorCode.InternalError,
+      message: "no result returned from function 'createPost'",
+    },
+  });
+});
+
+test("when there is no matching function for the path", async () => {
+  const config = {
+    functions: {
+      createPost: async () => {},
+    },
+    createFunctionAPI: () => {},
+  };
+
+  const rpcReq = createJSONRPCRequest("123", "unknown", { title: "a post" });
+
+  expect(await handleRequest(rpcReq, config)).toEqual({
+    id: "123",
+    jsonrpc: "2.0",
+    error: {
+      code: JSONRPCErrorCode.MethodNotFound,
+      message: "no corresponding function found for 'unknown'",
+    },
+  });
+});
+
+test("when there is an unexpected error in the custom function", async () => {
+  const config = {
+    functions: {
+      createPost: () => {
+        throw new Error("oopsie daisy");
+      },
+    },
+    createFunctionAPI: () => {},
+  };
+
+  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
+
+  expect(await handleRequest(rpcReq, config)).toEqual({
+    id: "123",
+    jsonrpc: "2.0",
+    error: {
+      code: JSONRPCErrorCode.InternalError,
+      message: "oopsie daisy",
+    },
+  });
+});
+
+test("when there is an unexpected object thrown in the custom function", async () => {
+  const config = {
+    functions: {
+      createPost: () => {
+        throw { err: "oopsie daisy" };
+      },
+    },
+    createFunctionAPI: () => {},
+  };
+
+  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
+
+  expect(await handleRequest(rpcReq, config)).toEqual({
+    id: "123",
+    jsonrpc: "2.0",
+    error: {
+      code: JSONRPCErrorCode.InternalError,
+      message: '{"err":"oopsie daisy"}',
+    },
+  });
+});

package/src/index.d.ts

@@ -0,0 +1,35 @@
+export type IDWhereCondition = {
+  equals?: string;
+  oneOf?: string[];
+};
+
+export type StringWhereCondition = {
+  startsWith?: string;
+  endsWith?: string;
+  oneOf?: string[];
+  contains?: string;
+  notEquals?: string;
+  equals?: string;
+};
+
+export type BooleanWhereCondition = {
+  equals?: boolean;
+  notEquals?: boolean;
+};
+
+export type NumberWhereCondition = {
+  greaterThan?: number;
+  greaterThanOrEquals?: number;
+  lessThan?: number;
+  lessThanOrEquals?: number;
+  equals?: number;
+  notEquals?: number;
+};
+
+export type DateWhereCondition = {
+  equals?: Date;
+  before?: Date;
+  onOrBefore?: Date;
+  after?: Date;
+  onOrAfter?: Date;
+};

package/src/index.js

@@ -0,0 +1,9 @@
+const { ModelAPI } = require("./ModelAPI");
+const { handleRequest } = require("./handleRequest");
+const { getDatabase } = require("./database");
+
+module.exports = {
+  ModelAPI,
+  handleRequest,
+  getDatabase,
+};

package/dist/index.d.ts

@@ -1,296 +0,0 @@
-declare module '@teamkeel/functions-runtime/constraints' {
-  export type StringConstraint = string | {
-      startsWith?: string;
-      endsWith?: string;
-      oneOf?: string[];
-      contains?: string;
-      notEquals?: string;
-      equals?: string;
-  };
-  export type NumberConstraint = number | {
-      greaterThan?: number;
-      greaterThanOrEquals?: number;
-      lessThan?: number;
-      lessThanOrEquals?: number;
-      equals?: number;
-      notEquals?: number;
-  };
-  export type BooleanConstraint = boolean | {
-      equals?: boolean;
-      notEquals?: boolean;
-  };
-  export type DateConstraint = Date | {
-      equals?: Date;
-      before?: Date;
-      onOrBefore?: Date;
-      after?: Date;
-      onOrAfter?: Date;
-  };
-  export type EnumConstraint = StringConstraint;
-
-}
-declare module '@teamkeel/functions-runtime/customFunctions/index' {
-  import { Config, CustomFunctionResponsePayload, CustomFunctionRequestPayload } from "@teamkeel/functions-runtime/types";
-  const handler: ({ method, params, id }: CustomFunctionRequestPayload, config: Config) => Promise<CustomFunctionResponsePayload>;
-  export default handler;
-
-}
-declare module '@teamkeel/functions-runtime/db/query' {
-  export type SqlQueryParts = SqlQueryPart[];
-  export type SqlQueryPart = RawSql | SqlInput;
-  export type RawSql = {
-      type: "sql";
-      value: string;
-  };
-  export type SqlInput = {
-      type: "input";
-      value: any;
-  };
-  export function rawSql(sql: string): SqlQueryPart;
-  export function sqlIdentifier(identifier: string, identifierField?: string | null): SqlQueryPart;
-  export function sqlInput(input: any): SqlQueryPart;
-  export function sqlInputArray(inputs: any[]): SqlQueryPart[];
-  export function sqlAddSeparator(parts: SqlQueryPart[], separator: SqlQueryPart): SqlQueryPart[];
-  export function sqlAddSeparatorAndFlatten(parts: SqlQueryPart[][], separator: SqlQueryPart): SqlQueryPart[];
-
-}
-declare module '@teamkeel/functions-runtime/db/resolver' {
-  import { SqlQueryParts } from "@teamkeel/functions-runtime/db/query";
-  export interface QueryResolver {
-      runQuery(query: SqlQueryParts): Promise<QueryResultRow[]>;
-      runRawQuery(query: string): Promise<QueryResultRow[]>;
-  }
-  export interface QueryResultRow {
-      [column: string]: any;
-  }
-  export function queryResolverFromEnv(env: Record<string, string | undefined>): QueryResolver;
-  export class PgQueryResolver implements QueryResolver {
-      private readonly pool;
-      constructor(config: {
-          connectionString: string;
-      });
-      runRawQuery(query: string): Promise<QueryResultRow[]>;
-      runQuery(query: SqlQueryParts): Promise<QueryResultRow[]>;
-      private toQuery;
-  }
-  export class AwsRdsDataClientQueryResolver implements QueryResolver {
-      private readonly client;
-      private readonly dbClusterResourceArn;
-      private readonly dbCredentialsSecretArn;
-      private readonly dbName;
-      constructor(config: {
-          region: string;
-          dbClusterResourceArn: string;
-          dbCredentialsSecretArn: string;
-          dbName: string;
-      });
-      runRawQuery(sql: string): Promise<QueryResultRow[]>;
-      runQuery(query: SqlQueryParts): Promise<QueryResultRow[]>;
-      private toQuery;
-      private toDataApiFormat;
-  }
-
-}
-declare module '@teamkeel/functions-runtime/fetch/index' {
-  import { RequestInit } from "node-fetch";
-  type RequestOpts = Omit<RequestInit, "referrer">;
-  const _default: (uri: string, opts: RequestOpts) => Promise<import("node-fetch").Response>;
-  export default _default;
-
-}
-declare module '@teamkeel/functions-runtime/index' {
-  import Query, { ChainableQuery } from "@teamkeel/functions-runtime/query";
-  import * as QueryConstraints from "@teamkeel/functions-runtime/constraints";
-  import Logger, { ConsoleTransport, Level as LogLevel } from "@teamkeel/functions-runtime/logger/index";
-  import { Identity } from "@teamkeel/functions-runtime/types";
-  import handleCustomFunction from "@teamkeel/functions-runtime/customFunctions/index";
-  export * from "@teamkeel/functions-runtime/returnTypes";
-  export * from "@teamkeel/functions-runtime/db/resolver";
-  import { queryResolverFromEnv } from "@teamkeel/functions-runtime/db/resolver";
-  export { Query, ChainableQuery, QueryConstraints, Logger, ConsoleTransport, LogLevel, Identity, queryResolverFromEnv, handleCustomFunction, };
-
-}
-declare module '@teamkeel/functions-runtime/logger/index' {
-  export enum Level {
-      Info = "info",
-      Error = "error",
-      Debug = "debug",
-      Warn = "warn",
-      Success = "success"
-  }
-  export interface LoggerOptions {
-      transport?: Transport;
-      colorize?: boolean;
-      timestamps?: boolean;
-  }
-  export interface Transport {
-      log: (msg: Msg, level: Level, options: LoggerOptions) => void;
-  }
-  export class ConsoleTransport implements Transport {
-      log: (msg: Msg, level: Level, options: LoggerOptions) => void;
-  }
-  type Msg = any;
-  export default class Logger {
-      private readonly options;
-      constructor(opts?: LoggerOptions);
-      log: (msg: Msg, level?: Level) => void;
-  }
-  export {};
-
-}
-declare module '@teamkeel/functions-runtime/query' {
-  import { Conditions, ChainedQueryOpts, QueryOpts, Input, OrderClauses } from "@teamkeel/functions-runtime/types";
-  import * as ReturnTypes from "@teamkeel/functions-runtime/returnTypes";
-  import { QueryResultRow } from "@teamkeel/functions-runtime/db/resolver";
-  export class ChainableQuery<T extends IDer> {
-      private readonly tableName;
-      private readonly conditions;
-      private orderClauses;
-      private readonly queryResolver;
-      private readonly logger;
-      constructor({ tableName, queryResolver, conditions, logger, }: ChainedQueryOpts<T>);
-      orWhere: (conditions: Conditions<T>) => ChainableQuery<T>;
-      all: () => Promise<ReturnTypes.FunctionListResponse<T>>;
-      findOne: () => Promise<ReturnTypes.FunctionGetResponse<T>>;
-      order: (clauses: OrderClauses<T>) => ChainableQuery<T>;
-      private appendConditions;
-      private execute;
-  }
-  interface IDer {
-      id: string;
-  }
-  export default class Query<T extends IDer> {
-      private readonly tableName;
-      private readonly conditions;
-      private readonly queryResolver;
-      private readonly logger;
-      constructor({ tableName, queryResolver, logger }: QueryOpts);
-      create: (inputs: Partial<T>) => Promise<ReturnTypes.FunctionCreateResponse<T>>;
-      raw: (sql: string) => Promise<QueryResultRow[]>;
-      where: (conditions: Conditions<T>) => ChainableQuery<T>;
-      delete: (id: string) => Promise<ReturnTypes.FunctionDeleteResponse<T>>;
-      findOne: (conditions: Conditions<T>) => Promise<ReturnTypes.FunctionGetResponse<T>>;
-      update: (id: string, inputs: Input<T>) => Promise<ReturnTypes.FunctionUpdateResponse<T>>;
-      all: () => Promise<ReturnTypes.FunctionListResponse<T>>;
-      private execute;
-  }
-  export {};
-
-}
-declare module '@teamkeel/functions-runtime/queryBuilders/index' {
-  import { Conditions, Constraints, OrderClauses, OrderDirection } from "@teamkeel/functions-runtime/types";
-  import { SqlQueryParts } from "@teamkeel/functions-runtime/db/query";
-  export const buildSelectStatement: <T>(tableName: string, conditions: Partial<{ [K in keyof T]: Constraints<T[K]>; }>[], order?: Partial<Record<keyof T, OrderDirection>>, limit?: number) => SqlQueryParts;
-  export const buildCreateStatement: <T>(tableName: string, inputs: Partial<T>) => SqlQueryParts;
-  export const buildUpdateStatement: <T>(tableName: string, id: string, inputs: Partial<T>) => SqlQueryParts;
-  export const buildDeleteStatement: <T>(tableName: string, id: string) => SqlQueryParts;
-
-}
-declare module '@teamkeel/functions-runtime/returnTypes' {
-  export interface ValidationError {
-      field: string;
-      message: string;
-      code: string;
-  }
-  export interface ExecutionError {
-      message: string;
-      stack: string;
-  }
-  export type FunctionError = ValidationError | ExecutionError;
-  export interface FunctionCreateResponse<T> {
-      object?: T;
-      errors?: FunctionError[];
-  }
-  export interface FunctionGetResponse<T> {
-      object?: T;
-      errors?: FunctionError[];
-  }
-  export interface FunctionDeleteResponse<T> {
-      success: boolean;
-      errors?: FunctionError[];
-  }
-  export interface FunctionListResponse<T> {
-      collection: T[];
-      errors?: FunctionError[];
-  }
-  export interface FunctionUpdateResponse<T> {
-      object?: T;
-      errors?: FunctionError[];
-  }
-  export interface FunctionAuthenticateResponse {
-      identityId?: string;
-      identityCreated: boolean;
-      errors?: FunctionError[];
-  }
-
-}
-declare module '@teamkeel/functions-runtime/staticAnalysis/analyse' {
-  export interface AnalyseOptions {
-      path: string;
-  }
-  const _default: (opts: AnalyseOptions) => Promise<import("@structured-types/api").PropTypes>;
-  export default _default;
-
-}
-declare module '@teamkeel/functions-runtime/staticAnalysis/cli' {
-  export {};
-
-}
-declare module '@teamkeel/functions-runtime/types' {
-  import { JSONRPCRequest, JSONRPCResponse } from "json-rpc-2.0";
-  import { StringConstraint, BooleanConstraint, NumberConstraint, DateConstraint, EnumConstraint } from "@teamkeel/functions-runtime/constraints";
-  import { Logger } from "@teamkeel/functions-runtime/index";
-  import Query from "@teamkeel/functions-runtime/query";
-  import { QueryResolver } from "@teamkeel/functions-runtime/db/resolver";
-  export interface QueryOpts {
-      tableName: string;
-      queryResolver: QueryResolver;
-      logger: Logger;
-  }
-  export interface ChainedQueryOpts<T> extends QueryOpts {
-      conditions: Conditions<T>[];
-  }
-  export type Constraints<T> = T extends String ? StringConstraint : T extends Boolean ? BooleanConstraint : T extends Number ? NumberConstraint : T extends Date ? DateConstraint : EnumConstraint;
-  export type Input<T> = Record<keyof T, unknown>;
-  export type Conditions<T> = Partial<{
-      [K in keyof T]: Constraints<T[K]>;
-  }>;
-  export interface BuiltInFields {
-      id: string;
-      createdAt: Date;
-      updatedAt: Date;
-  }
-  export type OrderDirection = "ASC" | "DESC";
-  export type OrderClauses<T> = Partial<Record<keyof T, OrderDirection>>;
-  export interface Identity {
-      id: string;
-      email: string;
-  }
-  export type CustomFunctionRequestPayload = JSONRPCRequest;
-  export type CustomFunctionResponsePayload = JSONRPCResponse;
-  export type CustomFunction = (inputs: any, api: API) => Promise<any>;
-  type API = {
-      [apiName: string]: Query<BuiltInFields>;
-  };
-  export type Functions = Record<string, CustomFunction>;
-  export interface Config {
-      functions: Functions;
-      api: API;
-  }
-  export {};
-
-}
-declare module '@teamkeel/functions-runtime/util/camelCaser' {
-  const _default: (input: string) => string;
-  export default _default;
-
-}
-declare module '@teamkeel/functions-runtime/util/snakeCaser' {
-  const _default: (input: string) => string;
-  export default _default;
-
-}
-declare module '@teamkeel/functions-runtime' {
-  import main = require('@teamkeel/functions-runtime/index');
-  export = main;
-}