@ruiapp/rapid-core 0.1.54 → 0.1.56

package/src/deno-std/assert/assert.ts

@@ -1,9 +1,9 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-import { AssertionError } from "./assertion_error";
-
-/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
-export function assert(expr: unknown, msg = ""): asserts expr {
-  if (!expr) {
-    throw new AssertionError(msg);
-  }
-}
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error";
+
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+export function assert(expr: unknown, msg = ""): asserts expr {
+  if (!expr) {
+    throw new AssertionError(msg);
+  }
+}

package/src/deno-std/assert/assertion_error.ts

@@ -1,7 +1,7 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-export class AssertionError extends Error {
-  override name = "AssertionError";
-  constructor(message: string) {
-    super(message);
-  }
-}
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+export class AssertionError extends Error {
+  override name = "AssertionError";
+  constructor(message: string) {
+    super(message);
+  }
+}

package/src/helpers/inputHelper.ts

@@ -1,11 +1,11 @@
-import { isArray, mergeWith } from "lodash";
-
-export function mergeInput(defaultInput: any, input: any, fixedInput: any) {
-  return mergeWith({}, defaultInput, input, fixedInput, doNotMergeArray);
-}
-
-function doNotMergeArray(objValue: any, srcValue: any) {
-  if (isArray(srcValue)) {
-    return srcValue;
-  }
-}
+import { isArray, mergeWith } from "lodash";
+
+export function mergeInput(defaultInput: any, input: any, fixedInput: any) {
+  return mergeWith({}, defaultInput, input, fixedInput, doNotMergeArray);
+}
+
+function doNotMergeArray(objValue: any, srcValue: any) {
+  if (isArray(srcValue)) {
+    return srcValue;
+  }
+}

package/src/plugins/dataManage/actionHandlers/addEntityRelations.ts

@@ -13,7 +13,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   logger.debug(`Running ${code} handler...`, { defaultInput, fixedInput, mergedInput });
 
   const entityManager = server.getEntityManager(options.singularCode);
-  mergedInput.routerContext = ctx.routerContext;
+  mergedInput.routeContext = ctx.routerContext;
   await entityManager.addRelations(mergedInput, plugin);
 
   ctx.output = {};

package/src/plugins/dataManage/actionHandlers/countCollectionEntities.ts

@@ -1,4 +1,4 @@
-import { RunEntityActionHandlerOptions } from "~/types";
+import { CountEntityOptions, RunEntityActionHandlerOptions } from "~/types";
 import runCollectionEntityActionHandler from "~/helpers/runCollectionEntityActionHandler";
 import { removeFiltersWithNullValue } from "~/dataAccess/filterHelper";
 import { ActionHandlerContext } from "~/core/actionHandler";
@@ -7,8 +7,9 @@ import { RapidPlugin } from "~/core/server";
 export const code = "countCollectionEntities";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: RunEntityActionHandlerOptions) {
-  await runCollectionEntityActionHandler(ctx, options, code, (entityManager, input) => {
+  await runCollectionEntityActionHandler(ctx, options, code, (entityManager, input: CountEntityOptions) => {
     input.filters = removeFiltersWithNullValue(input.filters);
+    input.routeContext = ctx.routerContext;
     return entityManager.count(input);
   });
 }

package/src/plugins/dataManage/actionHandlers/createCollectionEntitiesBatch.ts

@@ -30,7 +30,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
     const newEntity = await entityManager.createEntity(
       {
         entity: mergedEntity,
-        routerContext: ctx.routerContext,
+        routeContext: ctx.routerContext,
       },
       plugin,
     );

package/src/plugins/dataManage/actionHandlers/createCollectionEntity.ts

@@ -21,7 +21,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   const output = await entityManager.createEntity(
     {
       entity: input,
-      routerContext: ctx.routerContext,
+      routeContext: ctx.routerContext,
     },
     plugin,
   );

package/src/plugins/dataManage/actionHandlers/deleteCollectionEntityById.ts

@@ -9,7 +9,10 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   logger.debug(`Running ${code} handler...`);
 
   const entityManager = server.getEntityManager(options.singularCode);
-  await entityManager.deleteById(input.id, plugin);
+  await entityManager.deleteById({
+    id: input.id,
+    routeContext: ctx.routerContext,
+  }, plugin);
 
   ctx.status = 200;
   ctx.output = {};

package/src/plugins/dataManage/actionHandlers/findCollectionEntities.ts

@@ -9,7 +9,7 @@ export const code = "findCollectionEntities";
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: RunEntityActionHandlerOptions) {
   await runCollectionEntityActionHandler(ctx, options, code, async (entityManager, input: FindEntityOptions) => {
     input.filters = removeFiltersWithNullValue(input.filters);
-    input.routerContext = ctx.routerContext;
+    input.routeContext = ctx.routerContext;
     const entities = await entityManager.findEntities(input);
     const result: {
       list: any;

package/src/plugins/dataManage/actionHandlers/findCollectionEntityById.ts

@@ -10,7 +10,10 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   const { id } = input;
 
   const entityManager = server.getEntityManager(options.singularCode);
-  const entity = await entityManager.findById(id);
+  const entity = await entityManager.findById({
+    id,
+    routeContext: ctx.routerContext,
+  });
   if (!entity) {
     throw new Error(`${options.namespace}.${options.singularCode} with id "${id}" was not found.`);
   }

package/src/plugins/dataManage/actionHandlers/removeEntityRelations.ts

@@ -1,4 +1,4 @@
-import { RunEntityActionHandlerOptions } from "~/types";
+import { RemoveEntityRelationsOptions, RunEntityActionHandlerOptions } from "~/types";
 import { mergeInput } from "~/helpers/inputHelper";
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { RapidPlugin } from "~/core/server";
@@ -9,8 +9,9 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   const { logger, server, input } = ctx;
   const { defaultInput, fixedInput } = options;
 
-  const mergedInput = mergeInput(defaultInput, input, fixedInput);
+  const mergedInput: RemoveEntityRelationsOptions = mergeInput(defaultInput, input, fixedInput);
   logger.debug(`Running ${code} handler...`, { defaultInput, fixedInput, mergedInput });
+  mergedInput.routeContext = ctx.routerContext;
 
   const entityManager = server.getEntityManager(options.singularCode);
   await entityManager.removeRelations(mergedInput, plugin);

package/src/plugins/dataManage/actionHandlers/updateCollectionEntityById.ts

@@ -1,4 +1,4 @@
-import { RunEntityActionHandlerOptions } from "~/types";
+import { RunEntityActionHandlerOptions, UpdateEntityByIdOptions } from "~/types";
 import { mergeInput } from "~/helpers/inputHelper";
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { RapidPlugin } from "~/core/server";
@@ -22,7 +22,14 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
     delete mergedInput.$stateProperties;
   }
 
+  const updateEntityByIdOptions: UpdateEntityByIdOptions = {
+    id: mergedInput.id,
+    entityToSave: mergedInput,
+    operation,
+    stateProperties,
+    routeContext: ctx.routerContext,
+  };
   const entityManager = server.getEntityManager(options.singularCode);
-  const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput, operation, stateProperties }, plugin);
+  const output = await entityManager.updateEntityById(updateEntityByIdOptions, plugin);
   ctx.output = output;
 }

package/src/plugins/metaManage/MetaManagePlugin.ts

@@ -161,6 +161,13 @@ type ColumnInformation = {
   numeric_scale: number;
 };
 
+type ConstraintInformation = {
+  table_schema: string;
+  table_name: string;
+  constraint_type: string;
+  constraint_name: string;
+};
+
 async function syncDatabaseSchema(server: IRpdServer, applicationConfig: RpdApplicationConfig) {
   const logger = server.getLogger();
   logger.info("Synchronizing database schema...");
@@ -187,7 +194,7 @@ async function syncDatabaseSchema(server: IRpdServer, applicationConfig: RpdAppl
     logger.debug(`Checking data columns for '${model.namespace}.${model.singularCode}'...`);
 
     for (const property of model.properties) {
-      let columnDDL;
+      let columnDDL = "";
       if (isRelationProperty(property)) {
         if (property.relation === "one") {
           const targetModel = applicationConfig.models.find((item) => item.singularCode === property.targetSingularCode);
@@ -222,6 +229,12 @@ async function syncDatabaseSchema(server: IRpdServer, applicationConfig: RpdAppl
                 selfIdColumnName: property.selfIdColumnName!,
               });
             }
+
+            const contraintName = `${property.linkTableName}_pk`;
+            columnDDL += `ALTER TABLE ${queryBuilder.quoteTable(({
+              schema: property.linkSchema,
+              tableName: property.linkTableName,
+            }))} ADD CONSTRAINT ${queryBuilder.quoteObject(contraintName)} PRIMARY KEY (id);`;
           } else {
             const targetModel = applicationConfig.models.find((item) => item.singularCode === property.targetSingularCode);
             if (!targetModel) {
@@ -307,6 +320,24 @@ async function syncDatabaseSchema(server: IRpdServer, applicationConfig: RpdAppl
       }
     }
   }
+
+  const sqlQueryConstraints = `SELECT table_schema, table_name, constraint_type, constraint_name FROM information_schema.table_constraints WHERE constraint_type = 'PRIMARY KEY';`;
+  const constraintsInDb: ConstraintInformation[] = await server.queryDatabaseObject(sqlQueryConstraints);
+  for (const model of applicationConfig.models) {
+    const expectedTableSchema = model.schema || server.databaseConfig.dbDefaultSchema;
+    const expectedTableName = model.tableName;
+    const expectedContraintName = `${expectedTableName}_pk`;
+    logger.debug(`Checking pk for '${expectedTableSchema}.${expectedTableName}'...`);
+    const constraintInDb = find(constraintsInDb, {
+      table_schema: expectedTableSchema,
+      table_name: expectedTableName,
+      constraint_type: "PRIMARY KEY",
+      constraint_name: expectedContraintName,
+    });
+    if (!constraintInDb) {
+      await server.queryDatabaseObject(`ALTER TABLE ${queryBuilder.quoteTable(model)} ADD CONSTRAINT ${queryBuilder.quoteObject(expectedContraintName)} PRIMARY KEY (id);`, []);
+    }
+  }
 }
 
 function generateCreateColumnDDL(
@@ -358,7 +389,7 @@ function generateLinkTableDDL(
   })} (`;
   columnDDL += `id serial not null,`;
   columnDDL += `${queryBuilder.quoteObject(options.selfIdColumnName)} integer not null,`;
-  columnDDL += `${queryBuilder.quoteObject(options.targetIdColumnName)} integer not null)`;
+  columnDDL += `${queryBuilder.quoteObject(options.targetIdColumnName)} integer not null);`;
 
   return columnDDL;
 }

package/src/plugins/serverOperation/actionHandlers/runServerOperation.ts

@@ -1,15 +1,15 @@
-import { ActionHandlerContext } from "~/core/actionHandler";
-import { RapidPlugin } from "~/core/server";
-
-export const code = "runServerOperation";
-
-export async function handler(
-  plugin: RapidPlugin,
-  ctx: ActionHandlerContext,
-  options: {
-    operation: (ctx: ActionHandlerContext) => Promise<void>;
-  },
-) {
-  const { operation } = options;
-  await operation(ctx);
-}
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
+
+export const code = "runServerOperation";
+
+export async function handler(
+  plugin: RapidPlugin,
+  ctx: ActionHandlerContext,
+  options: {
+    operation: (ctx: ActionHandlerContext) => Promise<void>;
+  },
+) {
+  const { operation } = options;
+  await operation(ctx);
+}

package/src/plugins/stateMachine/stateMachineHelper.ts

@@ -1,36 +1,36 @@
-import { DefaultStateMachineSnapshot, GetStateMachineNextSnapshotOptions, TryGetStateMachineNextSnapshotResult } from "./StateMachinePluginTypes";
-import { createMachine, getInitialSnapshot, getNextSnapshot } from "xstate";
-
-export async function getStateMachineNextSnapshot(options: GetStateMachineNextSnapshotOptions) {
-  const { machineConfig, currentState, event } = options;
-  machineConfig.initial = currentState;
-
-  const machine = createMachine(machineConfig);
-  const snapshot = getInitialSnapshot(machine);
-
-  if (!snapshot.can(event)) {
-    throw new Error(`'${event.type}' action is not allowed at '${currentState}' state.`);
-  }
-
-  const nextSnapshot = getNextSnapshot(machine, snapshot, event);
-  return nextSnapshot;
-}
-
-export async function tryGetStateMachineNextSnapshot(options: GetStateMachineNextSnapshotOptions): Promise<TryGetStateMachineNextSnapshotResult> {
-  const { machineConfig, currentState, event } = options;
-  machineConfig.initial = currentState;
-
-  const machine = createMachine(machineConfig);
-  const snapshot = getInitialSnapshot(machine);
-
-  const canTransfer = snapshot.can(event);
-  let nextSnapshot: DefaultStateMachineSnapshot;
-  if (canTransfer) {
-    nextSnapshot = getNextSnapshot(machine, snapshot, event);
-  }
-
-  return {
-    canTransfer,
-    nextSnapshot,
-  };
-}
+import { DefaultStateMachineSnapshot, GetStateMachineNextSnapshotOptions, TryGetStateMachineNextSnapshotResult } from "./StateMachinePluginTypes";
+import { createMachine, getInitialSnapshot, getNextSnapshot } from "xstate";
+
+export async function getStateMachineNextSnapshot(options: GetStateMachineNextSnapshotOptions) {
+  const { machineConfig, currentState, event } = options;
+  machineConfig.initial = currentState;
+
+  const machine = createMachine(machineConfig);
+  const snapshot = getInitialSnapshot(machine);
+
+  if (!snapshot.can(event)) {
+    throw new Error(`'${event.type}' action is not allowed at '${currentState}' state.`);
+  }
+
+  const nextSnapshot = getNextSnapshot(machine, snapshot, event);
+  return nextSnapshot;
+}
+
+export async function tryGetStateMachineNextSnapshot(options: GetStateMachineNextSnapshotOptions): Promise<TryGetStateMachineNextSnapshotResult> {
+  const { machineConfig, currentState, event } = options;
+  machineConfig.initial = currentState;
+
+  const machine = createMachine(machineConfig);
+  const snapshot = getInitialSnapshot(machine);
+
+  const canTransfer = snapshot.can(event);
+  let nextSnapshot: DefaultStateMachineSnapshot;
+  if (canTransfer) {
+    nextSnapshot = getNextSnapshot(machine, snapshot, event);
+  }
+
+  return {
+    canTransfer,
+    nextSnapshot,
+  };
+}

package/src/plugins/webhooks/pluginConfig.ts

@@ -1,74 +1,74 @@
-import { RpdApplicationConfig } from "~/types";
-
-export default {
-  models: [
-    {
-      name: "webhook",
-      namespace: "sys",
-      singularCode: "webhook",
-      pluralCode: "webhooks",
-      schema: "public",
-      tableName: "sys_webhooks",
-      properties: [
-        {
-          name: "id",
-          code: "id",
-          columnName: "id",
-          type: "integer",
-          required: true,
-          autoIncrement: true,
-        },
-        {
-          name: "name",
-          code: "name",
-          columnName: "name",
-          type: "text",
-          required: true,
-        },
-        {
-          name: "url",
-          code: "url",
-          columnName: "url",
-          type: "text",
-          required: true,
-        },
-        {
-          name: "secret",
-          code: "secret",
-          columnName: "secret",
-          type: "text",
-          required: false,
-        },
-        {
-          name: "namespace",
-          code: "namespace",
-          columnName: "namespace",
-          type: "text",
-          required: true,
-        },
-        {
-          name: "model singular code",
-          code: "modelSingularCode",
-          columnName: "model_singular_code",
-          type: "text",
-          required: true,
-        },
-        {
-          name: "events",
-          code: "events",
-          columnName: "events",
-          type: "json",
-          required: false,
-        },
-        {
-          name: "enabled",
-          code: "enabled",
-          columnName: "enabled",
-          type: "boolean",
-          required: true,
-        },
-      ],
-    },
-  ],
-  routes: [],
-} satisfies RpdApplicationConfig;
+import { RpdApplicationConfig } from "~/types";
+
+export default {
+  models: [
+    {
+      name: "webhook",
+      namespace: "sys",
+      singularCode: "webhook",
+      pluralCode: "webhooks",
+      schema: "public",
+      tableName: "sys_webhooks",
+      properties: [
+        {
+          name: "id",
+          code: "id",
+          columnName: "id",
+          type: "integer",
+          required: true,
+          autoIncrement: true,
+        },
+        {
+          name: "name",
+          code: "name",
+          columnName: "name",
+          type: "text",
+          required: true,
+        },
+        {
+          name: "url",
+          code: "url",
+          columnName: "url",
+          type: "text",
+          required: true,
+        },
+        {
+          name: "secret",
+          code: "secret",
+          columnName: "secret",
+          type: "text",
+          required: false,
+        },
+        {
+          name: "namespace",
+          code: "namespace",
+          columnName: "namespace",
+          type: "text",
+          required: true,
+        },
+        {
+          name: "model singular code",
+          code: "modelSingularCode",
+          columnName: "model_singular_code",
+          type: "text",
+          required: true,
+        },
+        {
+          name: "events",
+          code: "events",
+          columnName: "events",
+          type: "json",
+          required: false,
+        },
+        {
+          name: "enabled",
+          code: "enabled",
+          columnName: "enabled",
+          type: "boolean",
+          required: true,
+        },
+      ],
+    },
+  ],
+  routes: [],
+} satisfies RpdApplicationConfig;

package/src/proxy/types.ts

@@ -1,21 +1,21 @@
-import { RapidRequest } from "~/core/request";
-import { RunProxyHandlerOptions } from "../types";
-import { RapidResponse } from "~/core/response";
-
-export interface ProxyContext {
-  sourceContext: ProxySourceContext;
-  targetContext: ProxyTargetContext;
-  options: ProxyOptions;
-}
-
-export interface ProxySourceContext {
-  request: RapidRequest;
-  response: RapidResponse;
-}
-
-export interface ProxyTargetContext {
-  request?: RapidRequest;
-  response?: RapidResponse;
-}
-
-export type ProxyOptions = RunProxyHandlerOptions;
+import { RapidRequest } from "~/core/request";
+import { RunProxyHandlerOptions } from "../types";
+import { RapidResponse } from "~/core/response";
+
+export interface ProxyContext {
+  sourceContext: ProxySourceContext;
+  targetContext: ProxyTargetContext;
+  options: ProxyOptions;
+}
+
+export interface ProxySourceContext {
+  request: RapidRequest;
+  response: RapidResponse;
+}
+
+export interface ProxyTargetContext {
+  request?: RapidRequest;
+  response?: RapidResponse;
+}
+
+export type ProxyOptions = RunProxyHandlerOptions;

package/src/queryBuilder/index.ts

@@ -1 +1 @@
-export * from "./queryBuilder";
+export * from "./queryBuilder";

package/src/server.ts

@@ -1,5 +1,5 @@
 import DataAccessor from "./dataAccess/dataAccessor";
-import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty, CreateEntityOptions, UpdateEntityByIdOptions, EntityWatchHandlerContext, EntityWatcherType, RpdEntityCreateEventPayload } from "./types";
+import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty, CreateEntityOptions, UpdateEntityByIdOptions, EntityWatchHandlerContext, EntityWatcherType, RpdEntityCreateEventPayload, EmitServerEventOptions } from "./types";
 
 import QueryBuilder from "./queryBuilder/queryBuilder";
 import PluginManager from "./core/pluginManager";
@@ -237,9 +237,10 @@ export class RapidServer implements IRpdServer {
     this.#entityWatchers.push(entityWatcher);
   }
 
-  async emitEvent<K extends keyof RpdServerEventTypes>(eventName: K, payload: RpdServerEventTypes[K][1], sender?: RapidPlugin) {
+  async emitEvent<TEventName extends keyof RpdServerEventTypes>(event: EmitServerEventOptions<TEventName>) {
+    const { eventName, payload, sender, routeContext: routerContext } = event;
     this.#logger.debug(`Emitting '${eventName}' event.`, { eventName, payload });
-    await this.#eventManager.emit<K>(eventName, sender, payload as any);
+    await this.#eventManager.emit<TEventName>(eventName, sender, payload as any, routerContext);
 
     // TODO: should move this logic into metaManager
     // if (
@@ -392,11 +393,12 @@ export class RapidServer implements IRpdServer {
     await this.#pluginManager.beforeUpdateEntity(model, options, currentEntity);
   }
 
-  async #handleEntityEvent(eventName: keyof RpdServerEventTypes, sender: RapidPlugin, payload: RpdEntityCreateEventPayload) {
+  async #handleEntityEvent(eventName: keyof RpdServerEventTypes, sender: RapidPlugin, payload: RpdEntityCreateEventPayload, routerContext?: RouteContext) {
     const { modelSingularCode, baseModelSingularCode } = payload;
     const entityWatchHandlerContext: EntityWatchHandlerContext<typeof eventName> = {
       server: this,
       payload,
+      routerContext,
     };
 
     let emitter: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;