@ruiapp/rapid-core 0.0.1

package/src/plugins/authManager/httpHandlers/createSession.ts

@@ -0,0 +1,57 @@
+import { IPluginInstance } from "~/types";
+import { setCookie } from "~/deno-std/http/cookie";
+import { createJWT } from "~/utilities/jwtUtility";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export interface UserAccessToken {
+  sub: "userAccessToken",
+  aud: string;
+}
+
+export const code = "createSession";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: any,
+) {
+  const { server, input, routerContext } = ctx;
+  const { response } = routerContext;
+  const { account, password } = input;
+
+  const userDataAccessor = server.getDataAccessor({
+    singularCode: "oc_user",
+  });
+
+  const user = await userDataAccessor.findOne({
+    filters: [
+      {
+        operator: "eq",
+        field: "login",
+        value: account,
+      }
+    ]
+  });
+
+  if (!user) {
+    throw new Error("Wrong account or password.");
+  }
+
+  const token = await createJWT({
+    iss: "authManager",
+    sub: "userAccessToken",
+    aud: "" + user.id,
+    iat: new Date,
+    act: user.login,
+  } as UserAccessToken);
+
+  setCookie(response.headers, {
+    name: ctx.server.config.sessionCookieName,
+    value: token,
+    path: "/",
+  });
+
+  ctx.output = {
+    token,
+  };
+}

package/src/plugins/authManager/httpHandlers/deleteSession.ts

@@ -0,0 +1,22 @@
+import { HttpHandlerContext } from "~/core/httpHandler";
+import { setCookie } from "~/deno-std/http/cookie";
+import { IPluginInstance } from "~/types";
+
+export const code = "deleteSession";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: any,
+) {
+  const { server, input, routerContext } = ctx;
+  const { response } = routerContext;
+
+  setCookie(response.headers, {
+    name: ctx.server.config.sessionCookieName,
+    value: "",
+    path: "/",
+  });
+
+  routerContext.redirect("/signin");
+}

package/src/plugins/authManager/httpHandlers/getMyProfile.ts

@@ -0,0 +1,43 @@
+import { IPluginInstance } from "~/types";
+import { findEntity } from "~/dataAccess/entityManager";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "getMyProfile";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: any,
+) {
+  const { server, input, routerContext } = ctx;
+
+  const userId = routerContext.state.userId;
+  if (!userId) {
+    ctx.status = 401;
+    ctx.output = {
+      error: {
+        message: "You are not signed in."
+      }
+    }
+    return;
+  }
+
+  const userDataAccessor = server.getDataAccessor({
+    singularCode: "oc_user",
+  });
+
+  const user = await findEntity(server, userDataAccessor, {
+    filters: [
+      {
+        operator: "eq",
+        field: "id",
+        value: userId,
+      }
+    ],
+    properties: ["id", "name", "login", "email", "department", "roles", "state", "createdAt"],
+  });
+
+  ctx.output = {
+    user,
+  };
+}

package/src/plugins/authManager/httpHandlers/index.ts

@@ -0,0 +1,10 @@
+import { IPluginHttpHandler } from "~/core/httpHandler";
+import * as createSession from "./createSession";
+import * as deleteSession from "./deleteSession";
+import * as getMyProfile from "./getMyProfile";
+
+export default [
+  createSession,
+  deleteSession,
+  getMyProfile,
+] satisfies IPluginHttpHandler[];

package/src/plugins/authManager/mod.ts

@@ -0,0 +1,56 @@
+/**
+ * Meta manager plugin
+ */
+
+import * as _ from "lodash";
+import {
+  IPluginInstance,
+  RpdApplicationConfig,
+} from "~/types";
+import { IRpdServer, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+
+import pluginHttpHandlers from "./httpHandlers";
+import pluginModels from "./models";
+import pluginRoutes from "./routes";
+
+export const code = "authManager";
+export const description = "authManager";
+export const extendingAbilities: RpdServerPluginExtendingAbilities[] = [];
+export const configurableTargets: RpdServerPluginConfigurableTargetOptions[] = [];
+export const configurations: RpdConfigurationItemOptions[] = [];
+
+let _plugin: IPluginInstance;
+
+export async function initPlugin(plugin: IPluginInstance, server: IRpdServer) {
+  _plugin = plugin;
+}
+
+export async function registerHttpHandlers(server: IRpdServer) {
+  for (const httpHandler of pluginHttpHandlers) {
+    server.registerHttpHandler(_plugin, httpHandler);
+  }
+}
+
+export async function registerEventHandlers(server: IRpdServer) {
+}
+
+export async function configureModels(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  applicationConfig.models.push(...pluginModels);
+}
+
+export async function configureRoutes(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  applicationConfig.routes.push(...pluginRoutes);
+}
+
+export async function onApplicationLoaded(
+  server: IRpdServer,
+  applicationConfig: RpdApplicationConfig,
+) {
+  console.log("authManager.onApplicationLoaded");
+}

package/src/plugins/authManager/models/AccessToken.ts

@@ -0,0 +1,56 @@
+import { RpdDataModel } from "~/types";
+
+export default     {
+  maintainedBy: "authManager",
+  namespace: "auth",
+  name: "access_token",
+  singularCode: "access_token",
+  pluralCode: "access_tokens",
+  schema: "public",
+  tableName: "access_tokens",
+  properties: [
+    {
+      name: "id",
+      code: "id",
+      columnName: "id",
+      type: "integer",
+      required: true,
+      autoIncrement: true,
+    },
+    {
+      name: "token",
+      code: "token",
+      columnName: "token",
+      type: "text",
+      required: true,
+    },
+    {
+      name: "description",
+      code: "description",
+      columnName: "description",
+      type: "text",
+      required: false,
+    },
+    {
+      name: "ownerType",
+      code: "ownerType",
+      columnName: "owner_type",
+      type: "text",
+      required: true,
+    },
+    {
+      name: "ownerId",
+      code: "ownerId",
+      columnName: "owner_id",
+      type: "integer",
+      required: true,
+    },
+    {
+      name: "expirationTime",
+      code: "expirationTime",
+      columnName: "expiration_time",
+      type: "datetime",
+      required: true,
+    },
+  ],
+} as RpdDataModel;

package/src/plugins/authManager/models/index.ts

@@ -0,0 +1,5 @@
+import AccessToken from "./AccessToken";
+
+export default [
+  AccessToken,
+]

package/src/plugins/authManager/routes/getMyProfile.ts

@@ -0,0 +1,15 @@
+import { RpdRoute } from "~/types";
+
+export default {
+  namespace: "auth",
+  name: "auth.getMyProfile",
+  code: "",
+  type: "RESTful",
+  method: "get",
+  endpoint: "/api/me",
+  handlers: [
+    {
+      code: "getMyProfile",
+    },
+  ],
+} as RpdRoute;

package/src/plugins/authManager/routes/index.ts

@@ -0,0 +1,9 @@
+import getMyProfile from "./getMyProfile";
+import signin from "./signin";
+import signout from "./signout";
+
+export default [
+  getMyProfile,
+  signin,
+  signout,
+]

package/src/plugins/authManager/routes/signin.ts

@@ -0,0 +1,15 @@
+import { RpdRoute } from "~/types";
+
+export default {
+  namespace: "auth",
+  name: "auth.signin",
+  code: "",
+  type: "RESTful",
+  method: "post",
+  endpoint: "/api/signin",
+  handlers: [
+    {
+      code: "createSession",
+    },
+  ],
+} as RpdRoute;

package/src/plugins/authManager/routes/signout.ts

@@ -0,0 +1,15 @@
+import { RpdRoute } from "~/types";
+
+export default {
+  namespace: "auth",
+  name: "auth.signout",
+  code: "",
+  type: "RESTful",
+  method: "get",
+  endpoint: "/api/signout",
+  handlers: [
+    {
+      code: "deleteSession",
+    },
+  ],
+} as RpdRoute;

package/src/plugins/dataManager/httpHandlers/addEntityRelations.ts

@@ -0,0 +1,76 @@
+import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
+import { mergeInput } from "~/helpers/inputHelper";
+import { isRelationProperty } from "~/utilities/rapidUtility";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "addEntityRelations";
+
+interface AddEntityRelationsInput {
+  id: number;
+  property: string;
+  relations: {id?: number, [k: string]: any}[];
+}
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+) {
+  const { server, input } = ctx;
+  const { queryBuilder } = server;
+  const { defaultInput, fixedInput } = options;
+
+  console.debug(`Running ${code} handler...`);
+
+  console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+  const mergedInput = mergeInput(defaultInput, input, fixedInput);
+  console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+  console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+
+  const dataAccessor = server.getDataAccessor(options);
+  const model = dataAccessor.getModel();
+
+  const {id, property, relations} = mergedInput as AddEntityRelationsInput;
+  const row = await dataAccessor.findById(id);
+  if (!row) {
+    throw new Error(`${options.namespace}.${options.singularCode}  with id "${id}" was not found.`);
+  }
+
+  console.log(mergedInput);
+
+  const relationProperty = model.properties.find(e => e.code === property);
+  if (!relationProperty) {
+    throw new Error(`Property '${property}' was not found in ${options.namespace}.${options.singularCode}`);
+  }
+
+  if (!(isRelationProperty(relationProperty) && relationProperty.relation === "many")) {
+    throw new Error(`Operation 'createEntityRelations' is only supported on property of 'many' relation`);
+  }
+
+  if (relationProperty.linkTableName) {
+    for (const relation of relations) {
+      const command = `INSERT INTO ${queryBuilder.quoteTable({schema:relationProperty.linkSchema, tableName: relationProperty.linkTableName})} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)})
+  SELECT $1, $2 WHERE NOT EXISTS (
+    SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)}
+      FROM ${queryBuilder.quoteTable({schema:relationProperty.linkSchema, tableName: relationProperty.linkTableName})}
+      WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)}=$2
+    )`;
+      const params = [id, relation.id];
+      await server.queryDatabaseObject(command, params);
+    }
+  }
+
+  ctx.output = {};
+
+  server.emitEvent(
+    "entity.addRelations",
+    plugin,
+    {
+      namespace: options.namespace,
+      modelSingularCode: options.singularCode,
+      entity: row,
+      property,
+      relations: relations,
+    },
+  );
+}

package/src/plugins/dataManager/httpHandlers/countCollectionEntities.ts

@@ -0,0 +1,22 @@
+import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
+import runCollectionEntityHttpHandler from "~/helpers/runCollectionEntityHttpHandler";
+import { removeFiltersWithNullValue } from "~/dataAccess/filterHelper";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "countCollectionEntities";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+) {
+  await runCollectionEntityHttpHandler(
+    ctx,
+    options,
+    code,
+    (dataAccessor, input) => {
+      input.filters = removeFiltersWithNullValue(input.filters);
+      return dataAccessor.count(input);
+    },
+  );
+}

package/src/plugins/dataManager/httpHandlers/createCollectionEntitiesBatch.ts

@@ -0,0 +1,57 @@
+import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
+import { mergeInput } from "~/helpers/inputHelper";
+import { createEntity } from "~/dataAccess/entityManager";
+import { isArray } from "lodash";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "createCollectionEntitiesBatch";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+) {
+  const { server, input } = ctx;
+  const { defaultInput, fixedInput } = options;
+
+  console.debug(`Running ${code} handler...`);
+
+  const { entities } = input;
+  if (!isArray(entities)) {
+    throw new Error("input.entities should be an array.");
+  }
+
+  console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+  console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+
+  const output: any[] = [];
+  for(const entity of entities) {
+    const mergedEntity = mergeInput(defaultInput?.entity || {}, entity, fixedInput?.entity);
+    console.debug(`mergedEntity: ${JSON.stringify(mergedEntity)}`);
+
+    const userId = ctx.routerContext.state?.userId;
+    if (userId) {
+      mergedEntity.createdBy = userId;
+    }
+
+    const dataAccessor = server.getDataAccessor(options);
+    const newEntity = await createEntity(server, dataAccessor, {
+      entity: mergedEntity,
+    });
+
+    server.emitEvent(
+      "entity.create",
+      plugin,
+      {
+        namespace: options.namespace,
+        modelSingularCode: options.singularCode,
+        after: newEntity,
+      },
+    );
+
+    output.push(newEntity);
+  }
+
+  ctx.output = output;
+
+}

package/src/plugins/dataManager/httpHandlers/createCollectionEntity.ts

@@ -0,0 +1,43 @@
+import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
+import { mergeInput } from "~/helpers/inputHelper";
+import { createEntity } from "~/dataAccess/entityManager";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "createCollectionEntity";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+) {
+  const { server, input } = ctx;
+  const { defaultInput, fixedInput } = options;
+
+  console.debug(`Running ${code} handler...`);
+
+  console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+  const mergedInput = mergeInput(defaultInput, input, fixedInput);
+  console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+  console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+
+  const userId = ctx.routerContext.state?.userId;
+  if (userId) {
+    input.createdBy = userId;
+  }
+
+  const dataAccessor = server.getDataAccessor(options);
+  const output = await createEntity(server, dataAccessor, {
+    entity: input,
+  });
+  ctx.output = output;
+
+  server.emitEvent(
+    "entity.create",
+    plugin,
+    {
+      namespace: options.namespace,
+      modelSingularCode: options.singularCode,
+      after: output,
+    },
+  );
+}

package/src/plugins/dataManager/httpHandlers/deleteCollectionEntityById.ts

@@ -0,0 +1,38 @@
+import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
+import { mapDbRowToEntity } from "~/dataAccess/entityMapper";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "deleteCollectionEntityById";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+) {
+  console.debug(`Running ${code} handler...`);
+  const { server, input } = ctx;
+
+  const dataAccessor = server.getDataAccessor(options);
+  const id = input.id;
+  const row = await dataAccessor.findById(id);
+  if (!row) {
+    ctx.routerContext.status = 200;
+    return;
+  }
+
+  await dataAccessor.deleteById(id);
+
+  const entity = mapDbRowToEntity(dataAccessor.getModel(), row);
+
+  server.emitEvent(
+    "entity.delete",
+    plugin,
+    {
+      namespace: options.namespace,
+      modelSingularCode: options.singularCode,
+      before: entity,
+    },
+  );
+
+  ctx.routerContext.status = 200;
+}

package/src/plugins/dataManager/httpHandlers/findCollectionEntities.ts

@@ -0,0 +1,35 @@
+import * as _ from "lodash";
+import { FindEntityOptions, IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
+import runCollectionEntityHttpHandler from "~/helpers/runCollectionEntityHttpHandler";
+import { findEntities } from "~/dataAccess/entityManager";
+import { removeFiltersWithNullValue } from "~/dataAccess/filterHelper";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "findCollectionEntities";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+) {
+  await runCollectionEntityHttpHandler(
+    ctx,
+    options,
+    code,
+    async (dataAccessor, input: FindEntityOptions) => {
+      input.filters = removeFiltersWithNullValue(input.filters);
+      const entities = await findEntities(ctx.server, dataAccessor, input);
+      const result: {
+        list: any;
+        total?: any;
+      } = { list: entities };
+
+      if (input.pagination && !input.pagination.withoutTotal) {
+        // TOOD: impl count entities by using entity manager, because DataAccessor does not support 'exists' and 'notExists' filter.
+        const countResult = await dataAccessor.count(input);
+        result.total = countResult.count;
+      }
+      return result;
+    },
+  );
+}

package/src/plugins/dataManager/httpHandlers/findCollectionEntityById.ts

@@ -0,0 +1,30 @@
+import { IPluginInstance, RunEntityHttpHandlerOptions } from "~/types";
+import { findEntity } from "~/dataAccess/entityManager";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "findCollectionEntityById";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+) {
+  console.debug(`Running ${code} handler...`);
+  const { server, input } = ctx;
+  const { id } = input;
+
+  const dataAccessor = server.getDataAccessor(options);
+  const user = await findEntity(ctx.server, dataAccessor, {
+    filters: [
+      {
+        operator: "eq",
+        field: "id",
+        value: id,
+      }
+    ],
+  });
+  if (!user) {
+    throw new Error(`${options.namespace}.${options.singularCode} with id "${id}" was not found.`);
+  }
+  ctx.output = user;
+}

package/src/plugins/dataManager/httpHandlers/queryDatabase.ts

@@ -0,0 +1,29 @@
+import * as _ from "lodash";
+import { IPluginInstance, RunQueryDatabaseHandlerOptions } from "~/types";
+import { mergeInput } from "~/helpers/inputHelper";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+export const code = "queryDatabase";
+
+export async function handler(
+  plugin: IPluginInstance,
+  ctx: HttpHandlerContext,
+  options: RunQueryDatabaseHandlerOptions,
+) {
+  const { server, input } = ctx;
+  const { sql, querySingle, defaultInput, fixedInput } = options;
+
+  console.debug(`Running ${code} handler...`);
+
+  console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
+  const mergedInput = mergeInput(defaultInput, input, fixedInput);
+  console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
+  console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
+
+  const result = await server.queryDatabaseObject(sql, mergedInput);
+  if (querySingle) {
+    ctx.output = _.first(result);
+  } else {
+    ctx.output = result;
+  }
+}