@ruiapp/rapid-core 0.0.1

package/src/dataAccess/entityMapper.ts

@@ -0,0 +1,74 @@
+import { RpdDataModel } from "~/types";
+import { isRelationProperty } from "~/utilities/rapidUtility";
+
+// TODO Generate mapper and cache it.
+
+export function mapDbRowToEntity(model: RpdDataModel, row: any) {
+  if (!row) {
+    return null;
+  }
+
+  if (!model.properties || !model.properties.length) {
+    return row;
+  }
+
+  const result: Record<string, any> = {};
+  const columnNames = Object.keys(row);
+  columnNames.forEach(columnName => {
+    let isRelationProp = false;
+    let propertyName = columnName;
+    let property = model.properties.find(item => item.columnName === columnName);
+    if (property) {
+      propertyName = property.code;
+    } else {
+      property = model.properties.find(item => item.relation === "one" && item.targetIdColumnName === columnName);
+      if (property) {
+        isRelationProp = true;
+        propertyName = property.code;
+      }
+    }
+
+    if (isRelationProp) {
+      if (row[propertyName] && !result[propertyName]) {
+        result[propertyName] = row[propertyName];
+      }
+    } else {
+      if (!result[propertyName]) {
+        result[propertyName] = row[columnName];
+      }
+    }
+  });
+
+  return result;
+}
+
+
+export function mapEntityToDbRow(model: RpdDataModel, entity: any) {
+  if (!entity) {
+    return null;
+  }
+
+  if (!model.properties || !model.properties.length) {
+    return entity;
+  }
+
+  const result: Record<string, any> = {};
+  const propertyNames = Object.keys(entity);
+  propertyNames.forEach(propertyName => {
+    let columnName = propertyName;
+    const property = model.properties.find(item => item.code === propertyName);
+    if (property) {
+      if (!isRelationProperty(property)) {
+        columnName = property.columnName || property.code;
+        result[columnName] = entity[propertyName];
+      }
+    } else {
+      const oneRelationProperty = model.properties.find(item => item.relation === "one" && item.targetIdColumnName === propertyName);
+      if (oneRelationProperty) {
+        result[propertyName] = entity[propertyName];
+      }
+    }
+  })
+
+  return result;
+}

package/src/dataAccess/filterHelper.ts

@@ -0,0 +1,47 @@
+import { EntityFilterOptions, FindEntityExistenceFilterOptions, FindEntityLogicalFilterOptions } from "~/types";
+import { isNullOrUndefined } from "~/utilities/typeUtility";
+
+export function removeFiltersWithNullValue(filters?: EntityFilterOptions[]) {
+  const result: EntityFilterOptions[] = [];
+  if (!filters) {
+    return result;
+  }
+
+  for (const filter of filters) {
+    const { operator } = filter;
+
+    switch (operator) {
+      case "null":
+      case "notNull":
+        result.push(filter);
+        break;
+      case "exists":
+      case "notExists":
+      case "and":
+      case "or":
+        const transformedFilter = transformFilterWithSubFilters(filter);
+        if (transformedFilter !== null) {
+          result.push(transformedFilter);
+        }
+        break;
+      default:
+        if (!isNullOrUndefined(filter.value)) {
+          result.push(filter);
+        }
+    }
+  }
+
+  return result;
+}
+
+function transformFilterWithSubFilters(
+  filter: FindEntityExistenceFilterOptions | FindEntityLogicalFilterOptions,
+): FindEntityExistenceFilterOptions | FindEntityLogicalFilterOptions | null {
+  const subFilters = removeFiltersWithNullValue(filter.filters);
+  if (!subFilters.length) {
+    return null;
+  }
+
+  filter.filters = subFilters;
+  return filter;
+}

package/src/dataAccess/propertyMapper.ts

@@ -0,0 +1,27 @@
+import { RpdDataModel } from "~/types";
+import { isRelationProperty } from "~/utilities/rapidUtility";
+
+export function mapPropertyNameToColumnName(model: RpdDataModel, propertyName: string) {
+  if (!model.properties) {
+    return propertyName;
+  }
+
+  const property = model.properties.find(item => item.code === propertyName);
+  if (!property) {
+    return propertyName;
+  }
+
+  if (isRelationProperty(property) && property.relation === "one") {
+    return property.targetIdColumnName!;
+  }
+
+  return property.columnName || property.code;
+}
+
+export function mapPropertyNamesToColumnNames(model: RpdDataModel, propertyNames: string[]) {
+  if (!propertyNames || !propertyNames.length) {
+    return [];
+  }
+
+  return propertyNames.map(fieldName => mapPropertyNameToColumnName(model, fieldName));
+}

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

@@ -0,0 +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);
+  }
+}

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

@@ -0,0 +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);
+  }
+}

package/src/deno-std/datetime/to_imf.ts

@@ -0,0 +1,47 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Formats the given date to IMF date time format. (Reference:
+ * https://tools.ietf.org/html/rfc7231#section-7.1.1.1).
+ * IMF is the time format to use when generating times in HTTP
+ * headers. The time being formatted must be in UTC for Format to
+ * generate the correct format.
+ *
+ * @example
+ * ```ts
+ * import { toIMF } from "https://deno.land/std@$STD_VERSION/datetime/to_imf.ts";
+ *
+ * toIMF(new Date(0)); // => returns "Thu, 01 Jan 1970 00:00:00 GMT"
+ * ```
+ * @param date Date to parse
+ * @return IMF date formatted string
+ */
+export function toIMF(date: Date): string {
+  function dtPad(v: string, lPad = 2): string {
+    return v.padStart(lPad, "0");
+  }
+  const d = dtPad(date.getUTCDate().toString());
+  const h = dtPad(date.getUTCHours().toString());
+  const min = dtPad(date.getUTCMinutes().toString());
+  const s = dtPad(date.getUTCSeconds().toString());
+  const y = date.getUTCFullYear();
+  const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const months = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+  ];
+  return `${days[date.getUTCDay()]}, ${d} ${
+    months[date.getUTCMonth()]
+  } ${y} ${h}:${min}:${s} GMT`;
+}

package/src/deno-std/http/cookie.ts

@@ -0,0 +1,398 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Structured similarly to Go's cookie.go
+// https://github.com/golang/go/blob/master/src/net/http/cookie.go
+// This module is browser compatible.
+
+import { assert } from "../assert/assert";
+import { toIMF } from "../datetime/to_imf";
+
+export interface Cookie {
+  /** Name of the cookie. */
+  name: string;
+  /** Value of the cookie. */
+  value: string;
+  /** The cookie's `Expires` attribute, either as an explicit date or UTC milliseconds.
+   * @example <caption>Explicit date:</caption>
+   *
+   * ```ts
+   * import { Cookie } from "https://deno.land/std@$STD_VERSION/http/cookie.ts";
+   * const cookie: Cookie = {
+   *   name: 'name',
+   *   value: 'value',
+   *   // expires on Fri Dec 30 2022
+   *   expires: new Date('2022-12-31')
+   * }
+   * ```
+   *
+   * @example <caption>UTC milliseconds</caption>
+   *
+   * ```ts
+   * import { Cookie } from "https://deno.land/std@$STD_VERSION/http/cookie.ts";
+   * const cookie: Cookie = {
+   *   name: 'name',
+   *   value: 'value',
+   *   // expires 10 seconds from now
+   *   expires: Date.now() + 10000
+   * }
+   * ```
+   */
+  expires?: Date | number;
+  /** The cookie's `Max-Age` attribute, in seconds. Must be a non-negative integer. A cookie with a `maxAge` of `0` expires immediately. */
+  maxAge?: number;
+  /** The cookie's `Domain` attribute. Specifies those hosts to which the cookie will be sent. */
+  domain?: string;
+  /** The cookie's `Path` attribute. A cookie with a path will only be included in the `Cookie` request header if the requested URL matches that path. */
+  path?: string;
+  /** The cookie's `Secure` attribute. If `true`, the cookie will only be included in the `Cookie` request header if the connection uses SSL and HTTPS. */
+  secure?: boolean;
+  /** The cookie's `HTTPOnly` attribute. If `true`, the cookie cannot be accessed via JavaScript. */
+  httpOnly?: boolean;
+  /**
+   * Allows servers to assert that a cookie ought not to
+   * be sent along with cross-site requests.
+   */
+  sameSite?: "Strict" | "Lax" | "None";
+  /** Additional key value pairs with the form "key=value" */
+  unparsed?: string[];
+}
+
+const FIELD_CONTENT_REGEXP = /^(?=[\x20-\x7E]*$)[^()@<>,;:\\"\[\]?={}\s]+$/;
+
+function toString(cookie: Cookie): string {
+  if (!cookie.name) {
+    return "";
+  }
+  const out: string[] = [];
+  validateName(cookie.name);
+  validateValue(cookie.name, cookie.value);
+  out.push(`${cookie.name}=${cookie.value}`);
+
+  // Fallback for invalid Set-Cookie
+  // ref: https://tools.ietf.org/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.1
+  if (cookie.name.startsWith("__Secure")) {
+    cookie.secure = true;
+  }
+  if (cookie.name.startsWith("__Host")) {
+    cookie.path = "/";
+    cookie.secure = true;
+    delete cookie.domain;
+  }
+
+  if (cookie.secure) {
+    out.push("Secure");
+  }
+  if (cookie.httpOnly) {
+    out.push("HttpOnly");
+  }
+  if (typeof cookie.maxAge === "number" && Number.isInteger(cookie.maxAge)) {
+    assert(
+      cookie.maxAge >= 0,
+      "Max-Age must be an integer superior or equal to 0",
+    );
+    out.push(`Max-Age=${cookie.maxAge}`);
+  }
+  if (cookie.domain) {
+    validateDomain(cookie.domain);
+    out.push(`Domain=${cookie.domain}`);
+  }
+  if (cookie.sameSite) {
+    out.push(`SameSite=${cookie.sameSite}`);
+  }
+  if (cookie.path) {
+    validatePath(cookie.path);
+    out.push(`Path=${cookie.path}`);
+  }
+  if (cookie.expires) {
+    const { expires } = cookie;
+    const dateString = toIMF(
+      typeof expires === "number" ? new Date(expires) : expires,
+    );
+    out.push(`Expires=${dateString}`);
+  }
+  if (cookie.unparsed) {
+    out.push(cookie.unparsed.join("; "));
+  }
+  return out.join("; ");
+}
+
+/**
+ * Validate Cookie Name.
+ * @param name Cookie name.
+ */
+function validateName(name: string | undefined | null) {
+  if (name && !FIELD_CONTENT_REGEXP.test(name)) {
+    throw new TypeError(`Invalid cookie name: "${name}".`);
+  }
+}
+
+/**
+ * Validate Path Value.
+ * See {@link https://tools.ietf.org/html/rfc6265#section-4.1.2.4}.
+ * @param path Path value.
+ */
+function validatePath(path: string | null) {
+  if (path == null) {
+    return;
+  }
+  for (let i = 0; i < path.length; i++) {
+    const c = path.charAt(i);
+    if (
+      c < String.fromCharCode(0x20) || c > String.fromCharCode(0x7E) || c == ";"
+    ) {
+      throw new Error(
+        path + ": Invalid cookie path char '" + c + "'",
+      );
+    }
+  }
+}
+
+/**
+ * Validate Cookie Value.
+ * See {@link https://tools.ietf.org/html/rfc6265#section-4.1}.
+ * @param value Cookie value.
+ */
+function validateValue(name: string, value: string | null) {
+  if (value == null || name == null) return;
+  for (let i = 0; i < value.length; i++) {
+    const c = value.charAt(i);
+    if (
+      c < String.fromCharCode(0x21) || c == String.fromCharCode(0x22) ||
+      c == String.fromCharCode(0x2c) || c == String.fromCharCode(0x3b) ||
+      c == String.fromCharCode(0x5c) || c == String.fromCharCode(0x7f)
+    ) {
+      throw new Error(
+        "RFC2616 cookie '" + name + "' cannot contain character '" + c + "'",
+      );
+    }
+    if (c > String.fromCharCode(0x80)) {
+      throw new Error(
+        "RFC2616 cookie '" + name + "' can only have US-ASCII chars as value" +
+          c.charCodeAt(0).toString(16),
+      );
+    }
+  }
+}
+
+/**
+ * Validate Cookie Domain.
+ * See {@link https://datatracker.ietf.org/doc/html/rfc6265#section-4.1.2.3}.
+ * @param domain Cookie domain.
+ */
+function validateDomain(domain: string) {
+  if (domain == null) {
+    return;
+  }
+  const char1 = domain.charAt(0);
+  const charN = domain.charAt(domain.length - 1);
+  if (char1 == "-" || charN == "." || charN == "-") {
+    throw new Error(
+      "Invalid first/last char in cookie domain: " + domain,
+    );
+  }
+}
+
+/**
+ * Parse cookies of a header
+ *
+ * @example
+ * ```ts
+ * import { getCookies } from "https://deno.land/std@$STD_VERSION/http/cookie.ts";
+ *
+ * const headers = new Headers();
+ * headers.set("Cookie", "full=of; tasty=chocolate");
+ *
+ * const cookies = getCookies(headers);
+ * console.log(cookies); // { full: "of", tasty: "chocolate" }
+ * ```
+ *
+ * @param headers The headers instance to get cookies from
+ * @return Object with cookie names as keys
+ */
+export function getCookies(headers: Headers): Record<string, string> {
+  const cookie = headers.get("Cookie");
+  if (cookie != null) {
+    const out: Record<string, string> = {};
+    const c = cookie.split(";");
+    for (const kv of c) {
+      const [cookieKey, ...cookieVal] = kv.split("=");
+      assert(cookieKey != null);
+      const key = cookieKey.trim();
+      out[key] = cookieVal.join("=");
+    }
+    return out;
+  }
+  return {};
+}
+
+/**
+ * Set the cookie header properly in the headers
+ *
+ * @example
+ * ```ts
+ * import {
+ *   Cookie,
+ *   setCookie,
+ * } from "https://deno.land/std@$STD_VERSION/http/cookie.ts";
+ *
+ * const headers = new Headers();
+ * const cookie: Cookie = { name: "Space", value: "Cat" };
+ * setCookie(headers, cookie);
+ *
+ * const cookieHeader = headers.get("set-cookie");
+ * console.log(cookieHeader); // Space=Cat
+ * ```
+ *
+ * @param headers The headers instance to set the cookie to
+ * @param cookie Cookie to set
+ */
+export function setCookie(headers: Headers, cookie: Cookie) {
+  // Parsing cookie headers to make consistent set-cookie header
+  // ref: https://tools.ietf.org/html/rfc6265#section-4.1.1
+  const v = toString(cookie);
+  if (v) {
+    headers.append("Set-Cookie", v);
+  }
+}
+
+/**
+ * Set the cookie header with empty value in the headers to delete it
+ *
+ * > Note: Deleting a `Cookie` will set its expiration date before now. Forcing
+ * > the browser to delete it.
+ *
+ * @example
+ * ```ts
+ * import { deleteCookie } from "https://deno.land/std@$STD_VERSION/http/cookie.ts";
+ *
+ * const headers = new Headers();
+ * deleteCookie(headers, "deno");
+ *
+ * const cookieHeader = headers.get("set-cookie");
+ * console.log(cookieHeader); // deno=; Expires=Thus, 01 Jan 1970 00:00:00 GMT
+ * ```
+ *
+ * @param headers The headers instance to delete the cookie from
+ * @param name Name of cookie
+ * @param attributes Additional cookie attributes
+ */
+export function deleteCookie(
+  headers: Headers,
+  name: string,
+  attributes?: { path?: string; domain?: string },
+) {
+  setCookie(headers, {
+    name: name,
+    value: "",
+    expires: new Date(0),
+    ...attributes,
+  });
+}
+
+function parseSetCookie(value: string): Cookie | null {
+  const attrs = value
+    .split(";")
+    .map((attr) => {
+      const [key, ...values] = attr.trim().split("=");
+      return [key, values.join("=")];
+    });
+  const cookie: Cookie = {
+    name: attrs[0][0],
+    value: attrs[0][1],
+  };
+
+  for (const [key, value] of attrs.slice(1)) {
+    switch (key.toLocaleLowerCase()) {
+      case "expires":
+        cookie.expires = new Date(value);
+        break;
+      case "max-age":
+        cookie.maxAge = Number(value);
+        if (cookie.maxAge < 0) {
+          console.warn(
+            "Max-Age must be an integer superior or equal to 0. Cookie ignored.",
+          );
+          return null;
+        }
+        break;
+      case "domain":
+        cookie.domain = value;
+        break;
+      case "path":
+        cookie.path = value;
+        break;
+      case "secure":
+        cookie.secure = true;
+        break;
+      case "httponly":
+        cookie.httpOnly = true;
+        break;
+      case "samesite":
+        cookie.sameSite = value as Cookie["sameSite"];
+        break;
+      default:
+        if (!Array.isArray(cookie.unparsed)) {
+          cookie.unparsed = [];
+        }
+        cookie.unparsed.push([key, value].join("="));
+    }
+  }
+  if (cookie.name.startsWith("__Secure-")) {
+    /** This requirement is mentioned in https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie but not the RFC. */
+    if (!cookie.secure) {
+      console.warn(
+        "Cookies with names starting with `__Secure-` must be set with the secure flag. Cookie ignored.",
+      );
+      return null;
+    }
+  }
+  if (cookie.name.startsWith("__Host-")) {
+    if (!cookie.secure) {
+      console.warn(
+        "Cookies with names starting with `__Host-` must be set with the secure flag. Cookie ignored.",
+      );
+      return null;
+    }
+    if (cookie.domain !== undefined) {
+      console.warn(
+        "Cookies with names starting with `__Host-` must not have a domain specified. Cookie ignored.",
+      );
+      return null;
+    }
+    if (cookie.path !== "/") {
+      console.warn(
+        "Cookies with names starting with `__Host-` must have path be `/`. Cookie has been ignored.",
+      );
+      return null;
+    }
+  }
+  return cookie;
+}
+
+/**
+ * Parse set-cookies of a header
+ *
+ * @example
+ * ```ts
+ * import { getSetCookies } from "https://deno.land/std@$STD_VERSION/http/cookie.ts";
+ *
+ * const headers = new Headers([
+ *   ["Set-Cookie", "lulu=meow; Secure; Max-Age=3600"],
+ *   ["Set-Cookie", "booya=kasha; HttpOnly; Path=/"],
+ * ]);
+ *
+ * const cookies = getSetCookies(headers);
+ * console.log(cookies); // [{ name: "lulu", value: "meow", secure: true, maxAge: 3600 }, { name: "booya", value: "kahsa", httpOnly: true, path: "/ }]
+ * ```
+ *
+ * @param headers The headers instance to get set-cookies from
+ * @return List of cookies
+ */
+export function getSetCookies(headers: Headers): Cookie[] {
+  // TODO(lino-levan): remove this ts-ignore when Typescript 5.2 lands in Deno
+  // @ts-ignore Typescript's TS Dom types will be out of date until 5.2
+  return headers.getSetCookie()
+    /** Parse each `set-cookie` header separately */
+    .map(parseSetCookie)
+    /** Skip empty cookies */
+    .filter(Boolean) as Cookie[];
+}

package/src/helpers/entityHelpers.ts

@@ -0,0 +1,24 @@
+export function getEntityPartChanges(
+  before: any,
+  after: any,
+): Record<string, any> | null {
+  if (!before) {
+    throw new Error("Argument 'before' can not be null.");
+  }
+
+  if (!after) {
+    throw new Error("Argument 'after' can not be null.");
+  }
+
+  let changed = null;
+  for (const key in after) {
+    if (after[key] != before[key]) {
+      if (changed) {
+        changed[key] = after[key];
+      } else {
+        changed = { [key]: after[key] };
+      }
+    }
+  }
+  return changed;
+}

package/src/helpers/inputHelper.ts

@@ -0,0 +1,11 @@
+import * as _ 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/helpers/runCollectionEntityHttpHandler.ts

@@ -0,0 +1,34 @@
+import * as _ from "lodash";
+import { IRpdDataAccessor, RunEntityHttpHandlerOptions } from "~/types";
+import { mergeInput } from "./inputHelper";
+import { HttpHandlerContext } from "~/core/httpHandler";
+
+type DataAccessHandler = (
+  dataAccessor: IRpdDataAccessor,
+  input: any,
+) => Promise<any>;
+
+export default async function runCollectionEntityHttpHandler(
+  ctx: HttpHandlerContext,
+  options: RunEntityHttpHandlerOptions,
+  code: string,
+  handleDataAccess: DataAccessHandler,
+) {
+  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 dataAccessor = server.getDataAccessor(options);
+  const result = handleDataAccess(dataAccessor, mergedInput);
+  if (result instanceof Promise) {
+    ctx.output = await result;
+  } else {
+    ctx.output = result;
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+import { fixBigIntJSONSerialize } from "./polyfill";
+fixBigIntJSONSerialize();
+
+export * from "./types";
+export * as RpdServer from "./server";
+export * from "./server";
+
+export * from "./core/request";
+export * from "./core/routeContext";
+export * from "./core/server";
+
+export * as bootstrapApplicationConfig from "./bootstrapApplicationConfig";