feat: add connection references info and related api calls + minor fixes (#30)

Author: eveffer

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@inspatial/cloud",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "license": "Apache-2.0",
   "exports": {
     ".": "./mod.ts",

src/auth/entries/user/fields/google-fields.ts

@@ -38,6 +38,7 @@ export const googleFields: Array<InField> = [{
   key: "googleAuthStatus",
   type: "ChoicesField",
   label: "Google Auth Status",
+  readOnly: true,
   choices: [{
     key: "authenticated",
     label: "Authenticated",

src/auth/entries/user/user-entry.ts

@@ -18,6 +18,22 @@ export const userEntry = new EntryType<User>("user", {
     ...userFields,
     ...googleFields,
   ],
+  fieldGroups: [{
+    key: "personal",
+    label: "Personal Information",
+    description: "Basic information about the user",
+    fields: ["profilePicture", "firstName", "lastName", "fullName", "email"],
+  }, {
+    key: "security",
+    label: "Security",
+    description: "Security related information",
+    fields: ["systemAdmin", "apiToken"],
+  }, {
+    key: "google",
+    label: "Google Account",
+    description: "Google account information",
+    fields: ["googlePicture", "googleAuthStatus"],
+  }],
   actions: [
     setPassword,
     validatePassword,

src/extension/core-extension.ts

@@ -81,7 +81,7 @@ export const coreExtension = new CloudExtension("core", {
     onboardingStep,
   ],
   middleware: [corsMiddleware, authMiddleware, inLiveMiddleware],
-  pathHandlers: [apiPathHandler, staticFilesHandler],
+  pathHandlers: [apiPathHandler],
   requestLifecycle: {
     setup: [authLifecycle],
   },

src/orm/api-actions/entries-group.ts

@@ -213,6 +213,28 @@ export const getEntryTypeInfoAction = new CloudAPIAction("getEntryTypeInfo", {
   }],
 });
 
+export const countConnections = new CloudAPIAction("countConnections", {
+  label: "Count Entry Connections",
+  description:
+    "Count the total entries referencing the provided entry id, grouped by entry type",
+  params: [{
+    key: "entryType",
+    type: "DataField",
+    label: "Entry Type",
+    description: "The Entry Type to count connections for",
+    required: true,
+  }, {
+    key: "id",
+    type: "DataField",
+    label: "ID",
+    description: "The ID of the Entry to count connections for",
+    required: true,
+  }],
+  async run({ orm, params: { entryType, id } }) {
+    return await orm.countConnections(entryType, id);
+  },
+});
+
 export const sum = new CloudAPIAction("sum", {
   label: "Get the sum of the selected fields for a given Entry Type",
   params: [{

src/orm/api-actions/groups.ts

@@ -1,6 +1,7 @@
 import { CloudAPIGroup } from "../../api/cloud-group.ts";
 import {
   count,
+  countConnections,
   createEntryAction,
   deleteEntryAction,
   getEntryAction,
@@ -35,6 +36,7 @@ export const entriesGroup = new CloudAPIGroup("entry", {
     createEntryAction,
     deleteEntryAction,
     getEntryListAction,
+    countConnections,
     sum,
     count,
   ],

src/orm/entry/entry-type.ts

@@ -3,6 +3,7 @@ import type {
   EntryActionConfig,
   EntryActionDefinition,
   EntryConfig,
+  EntryConnection,
   EntryHookDefinition,
   EntryIndex,
   EntryTypeConfig,
@@ -35,6 +36,7 @@ export class EntryType<
   defaultSortField?: FK;
   defaultSortDirection?: "asc" | "desc" = "asc";
   actions: Map<string, EntryActionDefinition> = new Map();
+  connections: Array<EntryConnection> = [];
   hooks: Record<EntryHookName, Array<EntryHookDefinition<E>>> = {
     beforeUpdate: [],
     afterCreate: [],
@@ -163,6 +165,7 @@ export class EntryType<
       defaultListFields: Array.from(this.defaultListFields).map((f) =>
         this.fields.get(f)!
       ),
+      connections: Array.from(this.connections.values()),
     };
   }
   #setChildrenParent() {

src/orm/entry/types.ts

@@ -164,3 +164,11 @@ export type EntryIndex<FK extends PropertyKey = PropertyKey> = {
   fields: Array<FK>;
   unique?: boolean;
 };
+
+export interface EntryConnection {
+  referencingEntry: string;
+  referencingEntryLabel: string;
+  referencingField: string;
+  referencingFieldLabel: string;
+  listFields: Array<InField>;
+}

src/orm/inspatial-orm.ts

@@ -400,6 +400,38 @@ export class InSpatialORM {
     return entry;
   }
 
+  async countConnections<E extends EntryBase = GenericEntry>(
+    entryName: E["_name"],
+    id: string,
+  ): Promise<
+    Array<{
+      entryType: string;
+      label: string;
+      fieldKey: string;
+      fieldLabel: string;
+      count: number;
+    }>
+  > {
+    const entryTypeObj = this.getEntryType(entryName);
+    const results = [];
+    for (const connection of entryTypeObj.connections) {
+      const count = await this.count(connection.referencingEntry, {
+        filter: [{
+          field: connection.referencingField,
+          op: "=",
+          value: id,
+        }],
+      });
+      results.push({
+        entryType: connection.referencingEntry,
+        label: connection.referencingEntryLabel,
+        fieldKey: connection.referencingField,
+        fieldLabel: connection.referencingFieldLabel,
+        count,
+      });
+    }
+    return results;
+  }
   async findEntry<E extends EntryBase = GenericEntry>(
     entryType: E["_name"],
     filter: DBFilter,

src/orm/roles/role.ts

@@ -26,7 +26,7 @@ import type {
 } from "~/orm/settings/settings-base.ts";
 import type { InField } from "~/orm/field/field-def-types.ts";
 import type { Choice } from "~/orm/field/types.ts";
-import type { EntryConfig } from "~/orm/entry/types.ts";
+import type { EntryConfig, EntryConnection } from "~/orm/entry/types.ts";
 import type { SettingsConfig } from "~/orm/settings/types.ts";
 
 import type { UserID } from "~/auth/types.ts";
@@ -137,6 +137,37 @@ export class Role {
       validateEntryType(this, entryType);
       registerFetchFields(this, entryType);
     }
+    this.#setupEntryConnections();
+  }
+  #setupEntryConnections(): void {
+    const connections = new Map<string, Array<EntryConnection>>();
+    for (const entryType of this.entryTypes.values()) {
+      const connectionsFields = entryType.fields.values().filter((field) =>
+        field.type === "ConnectionField"
+      );
+      for (const field of connectionsFields) {
+        if (!connections.has(field.entryType)) {
+          connections.set(field.entryType, []);
+        }
+        // const connectionEntryType = this.getEntryType(field.entryType);
+        connections.get(field.entryType)!.push({
+          referencingEntry: entryType.name,
+          referencingEntryLabel: entryType.label,
+          referencingField: field.key,
+          referencingFieldLabel: field.label || field.key,
+          listFields: entryType.info.defaultListFields,
+        });
+      }
+    }
+    for (const [entryName, connectionFields] of connections.entries()) {
+      const entryType = this.getEntryType(entryName);
+
+      entryType.connections = connectionFields;
+      entryType.info = {
+        ...entryType.info,
+        connections: connectionFields,
+      };
+    }
   }
   #setupSettingsTypes(): void {
     for (const settingsType of this.settingsTypes.values()) {