@lobb-js/core 0.13.0

package/src/types/config/config.ts

@@ -0,0 +1,66 @@
+import type { Context } from "hono";
+import type { CollectionsConfig } from "./collectionsConfig.ts";
+import type { Extension } from "../Extension.ts";
+import type { Migrations } from "../migrations.ts";
+import type { RelationsConfig } from "./relations.ts";
+import type { Workflow } from "../../workflows/WorkflowSystem.ts";
+
+// project schema
+type Server = {
+  url: string;
+  description?: string;
+};
+
+export type ProjectConfig = {
+  context?: string;
+  force_sync?: boolean;
+  info?: {
+    title?: string;
+    version?: string;
+    description?: string;
+  };
+  servers?: Server[];
+  [key: string]: unknown;
+};
+
+// server database connection
+export type DatabaseConfig = {
+  type?: "pg" | "mongo";
+  host: string;
+  port: number;
+  database: string;
+  username: string;
+  password: string;
+  pool_connections?: number;
+};
+
+// webserver
+type CORSOptions = {
+  origin:
+    | string
+    | string[]
+    | ((origin: string, c: Context) => string | undefined | null);
+  allowMethods?: string[];
+  allowHeaders?: string[];
+  maxAge?: number;
+  credentials?: boolean;
+  exposeHeaders?: string[];
+};
+
+export type WebConfig = {
+  host?: string;
+  port?: number;
+  cors?: CORSOptions;
+};
+
+// configuration
+export interface Config {
+  project: ProjectConfig;
+  database: DatabaseConfig;
+  web_server: WebConfig;
+  migrations?: Migrations;
+  workflows?: Workflow[];
+  extensions?: Extension[];
+  relations?: RelationsConfig;
+  collections: CollectionsConfig;
+}

package/src/types/config/relations.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+
+// Base RelationCollectionField schema
+export const RelationCollectionFieldSchema = z.object({
+  collection: z.string(),
+  field: z.string(),
+});
+
+// Regular relation schema
+const RelationSchema = z.object({
+  from: RelationCollectionFieldSchema,
+  to: RelationCollectionFieldSchema,
+});
+
+// Union of all relation types
+export const RelationsConfigSchema = z.array(RelationSchema);
+export type RelationsConfig = z.infer<typeof RelationsConfigSchema>;

package/src/types/filterSchema.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// Define primitive types
+const primitiveTypes = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
+  z.date(),
+]);
+
+const ArrayOfPrimitives = z.array(primitiveTypes);
+
+// Define range types
+const rangeTypes = z.union([
+  z.number(),
+  z.date(),
+  z.string(),
+]);
+
+// Basic filter operators without recursion
+export const basicFilterOperatorsSchema = z.object({
+  $eq: primitiveTypes.optional(),
+  $ne: primitiveTypes.optional(),
+  $in: ArrayOfPrimitives.optional(),
+  $nin: ArrayOfPrimitives.optional(),
+
+  // String matching
+  $contains: z.string().optional(),
+  $icontains: z.string().optional(),
+  $ncontains: z.string().optional(),
+  $incontains: z.string().optional(),
+
+  $starts_with: z.string().optional(),
+  $istarts_with: z.string().optional(),
+  $nstarts_with: z.string().optional(),
+  $instarts_with: z.string().optional(),
+
+  $ends_with: z.string().optional(),
+  $iends_with: z.string().optional(),
+  $nends_with: z.string().optional(),
+  $inends_with: z.string().optional(),
+
+  $regex: z.string().optional(),
+
+  // Comparison
+  $lt: rangeTypes.optional(),
+  $lte: rangeTypes.optional(),
+  $gt: rangeTypes.optional(),
+  $gte: rangeTypes.optional(),
+  $between: z.tuple([rangeTypes, rangeTypes]).optional(),
+  $nbetween: z.tuple([rangeTypes, rangeTypes]).optional(),
+}).strict();
+
+// Recursive filter operators schema with $and and $or
+const recursiveFilterOperatorsSchema: any = z.lazy(() =>
+  basicFilterOperatorsSchema.extend({
+    $and: z.array(recursiveFilterOperatorsSchema).optional(),
+    $or: z.array(recursiveFilterOperatorsSchema).optional(),
+  }).strict()
+);
+
+// Final filter schema which can accept both primitive types and operators
+export const filterSchema = z.record(
+  z.union([recursiveFilterOperatorsSchema, primitiveTypes]),
+);
+
+type FilterFieldPrimitiveValue =
+  | string
+  | number
+  | boolean
+  | null;
+
+type FilterFieldValue<C = any> =
+  | FilterFieldPrimitiveValue
+  | Array<Filter<C>>
+  | Record<string, Filter<C>>
+  | ((ctx: C) => FilterFieldPrimitiveValue);
+
+export type Filter<C = any> = {
+  [key: string]: FilterFieldValue<C> | Filter<C>;
+};
+
+// this is needed so that the AI in lobb studio knows how to generate a filter object
+export const filterJsonSchema = zodToJsonSchema(
+  filterSchema as any,
+);

package/src/types/index.ts

@@ -0,0 +1,38 @@
+export { DatabaseDriver } from "./DatabaseDriver.ts";
+export type { FindAllResult, MassReturn } from "./DatabaseDriver.ts";
+export type { ApiCollectionAction } from "./apiSchema.ts";
+export type { Config, WebConfig } from "./config/config.ts";
+export type { RelationsConfig } from "./config/relations.ts";
+export type {
+  CollectionConfig,
+  CollectionIndex,
+  CollectionIndexes,
+  CollectionsConfig,
+} from "./config/collectionsConfig.ts";
+export type { CollectionFieldsWithoutId } from "./config/collectionsConfig.ts";
+export type {
+  CollectionField,
+  CollectionFieldBase,
+} from "./config/collectionFields.ts";
+export type { Dashboard, Extension } from "./Extension.ts";
+export { Field } from "./Field.ts";
+export type { Migration, MigrationProps, Migrations } from "./migrations.ts";
+export type { Filter } from "./filterSchema.ts";
+export {
+  basicFilterOperatorsSchema,
+  filterJsonSchema,
+  filterSchema,
+} from "./filterSchema.ts";
+export type {
+  FindAllParamsInput,
+  FindAllParamsOutput,
+} from "./collectionServiceSchema.ts";
+export { findAllParamsSchema } from "./collectionServiceSchema.ts";
+export { CollectionConfigSchema } from "./config/collectionsConfig.ts";
+export type { CollectionControllers } from "./CollectionControllers.ts";
+export type {
+  HeartBeatMessage,
+  RequestMessage,
+  SubscribeMessage,
+} from "./websockets.ts";
+export type { ProcessorType } from "./workflows/processors.ts";

package/src/types/migrations.ts

@@ -0,0 +1,12 @@
+import type { DatabaseDriver } from "./DatabaseDriver.ts";
+
+export interface MigrationProps {
+  driver: DatabaseDriver;
+}
+
+export interface Migration {
+  up: (props: MigrationProps) => Promise<void>;
+  down?: (props: MigrationProps) => Promise<void>;
+}
+
+export type Migrations = Record<string, Migration>;

package/src/types/websockets.ts

@@ -0,0 +1,34 @@
+export interface HeartBeatMessage {
+  type: "heartbeat";
+  message: "ping" | "pong";
+}
+
+export interface SubscribeMessage {
+  type: "subscribe";
+  eventName: string;
+  filter?: any;
+}
+
+export interface EventMessage {
+  type: "event";
+  event: string;
+  data: any;
+}
+
+export interface RequestMessage {
+  type: "request";
+  url: string;
+  requestInit: RequestInit;
+  fireAndForget?: boolean;
+}
+
+export interface ResponseMessage {
+  type: "response";
+  body: string;
+}
+
+export type Message =
+  | HeartBeatMessage
+  | SubscribeMessage
+  | RequestMessage
+  | ResponseMessage;

package/src/types/workflows/processors.ts

@@ -0,0 +1 @@
+export type ProcessorType = "pre_processors" | "post_processors";

package/src/utils/lockCollectionToObject.ts

@@ -0,0 +1,204 @@
+import type { CollectionConfig } from "../types/index.ts";
+import { Lobb } from "../Lobb.ts";
+import { LobbError } from "../LobbError.ts";
+
+export interface LockCollectionToObjectProps {
+  collectionName: string;
+  object: Record<string, any>;
+}
+
+let preUpdateEntry: Record<string, any>;
+
+export function innerLockCollectionToObject(
+  props: LockCollectionToObjectProps,
+): CollectionConfig {
+  setWorkflowsForLockedCollections(props.collectionName, props.object);
+  return generateSchemasForLockedCollections(props.collectionName);
+}
+
+function generateSchemasForLockedCollections(
+  collectionName: string,
+): CollectionConfig {
+  return {
+    "indexes": {
+      [`${collectionName}_unique_index`]: {
+        "unique": true,
+        "fields": {
+          "key": {
+            "order": "asc",
+          },
+        },
+      },
+    },
+    "fields": {
+      "id": {
+        "type": "integer",
+      },
+      "key": {
+        "type": "string",
+        "length": 255,
+        "validators": {
+          "required": true,
+        },
+      },
+      "value": {
+        "type": "text",
+        "validators": {
+          "required": true,
+        },
+        "pre_processors": {
+          "default": "{}",
+        },
+        "ui": {
+          "input": {
+            "type": "code",
+            "args": {
+              "type": "json",
+              "height": 200,
+              // "types": "type Value = any",
+            },
+          },
+        },
+      },
+      "static": {
+        "type": "bool",
+        "pre_processors": {
+          "overwrite": false,
+        },
+        "validators": {
+          "required": true,
+        },
+      },
+    },
+  };
+}
+
+async function getCollectionElementById(
+  id: string,
+  collectionName: string,
+) {
+  const result = await Lobb.instance.collectionService.findOne({
+    collectionName,
+    id,
+  });
+  return result.data;
+}
+
+function setWorkflowsForLockedCollections(
+  collectionName: string,
+  object: Record<string, any>,
+) {
+  Lobb.instance.workflowSystem.add({
+    name: `${collectionName}CollectionLockInitWorkflow`,
+    eventName: "core.init",
+    handler: async () => {
+      const entries = (await Lobb.instance.collectionService.findAll({
+        collectionName,
+      })).data;
+      for (let index = 0; index < entries.length; index++) {
+        const entry = entries[index];
+        if (object[entry.key]) {
+          throw new LobbError({
+            code: "BAD_REQUEST",
+            message:
+              `The (${entry.key}) key you are trying to add already exists in the memory`,
+          });
+        }
+        object[entry.key] = JSON.parse(entry.value);
+      }
+    },
+  });
+
+  Lobb.instance.workflowSystem.add({
+    name: `${collectionName}CollectionLockCreateWorkflow`,
+    eventName: `core.store.createOne`,
+    handler: async (input) => {
+      if (input.collectionName === collectionName) {
+        const entry = input.data;
+        if (object[entry.key]) {
+          throw new LobbError({
+            code: "BAD_REQUEST",
+            message:
+              `The (${entry.key}) key you are trying to add already exists in the memory`,
+          });
+        }
+        object[entry.key] = JSON.parse(entry.value);
+      }
+      return input;
+    },
+  });
+
+  Lobb.instance.workflowSystem.add({
+    name: `${collectionName}CollectionLockPreUpdateWorkflow`,
+    eventName: `core.store.preUpdateOne`,
+    handler: async (input) => {
+      if (input.collectionName === collectionName) {
+        preUpdateEntry = await getCollectionElementById(
+          input.id,
+          collectionName,
+        );
+      }
+      return input;
+    },
+  });
+
+  Lobb.instance.workflowSystem.add({
+    name: `${collectionName}CollectionLockUpdateWorkflow`,
+    eventName: `core.store.updateOne`,
+    handler: async (input) => {
+      if (input.collectionName === collectionName) {
+        const entry = input.data;
+
+        // TODO: I cant update the same non static key if I try. it shows me the bellow error
+
+        if (object[entry.key]) {
+          throw new LobbError({
+            code: "BAD_REQUEST",
+            message:
+              `The (${entry.key}) key you are trying to add already exists in the memory`,
+          });
+        }
+
+        delete object[preUpdateEntry.key];
+        object[entry.key] = JSON.parse(entry.value);
+      }
+      return input;
+    },
+  });
+
+  Lobb.instance.workflowSystem.add({
+    name: `${collectionName}CollectionLockDeleteWorkflow`,
+    eventName: `core.store.deleteOne`,
+    handler: async (input) => {
+      if (input.collectionName === collectionName) {
+        const entry = input.data;
+        delete object[entry.key];
+      }
+      return input;
+    },
+  });
+
+  Lobb.instance.workflowSystem.add({
+    name: `${collectionName}CollectionLockFindAllWorkflow`,
+    eventName: `core.controllers.findAll`,
+    handler: async (input) => {
+      if (input.collectionName === collectionName) {
+        for (const [key, value] of Object.entries(object)) {
+          const entryExists = input.response.data.find((entry: any) =>
+            entry.key === key
+          );
+          if (!entryExists) {
+            input.response.data.push({
+              id: null,
+              key: key,
+              value: JSON.stringify(value),
+              static: true,
+              __disabled: true,
+            });
+            input.response.meta.totalCount = input.response.meta.totalCount + 1;
+          }
+        }
+      }
+    },
+  });
+}