@arken/seer-protocol 0.1.1 → 0.1.2

package/infinite/infinite.router.ts

@@ -1,8 +1,8 @@
 import { z as zod } from 'zod';
 import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '@arken/rpc';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
 import * as Arken from '@arken/node';
-import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/schema';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/node/schema';
 import { RouterContext } from '../../types';
 
 export const z = zod;
@@ -1316,20 +1316,20 @@ export type RouterOutput = inferRouterOutputs<Router>;
 //     }
 //   });
 
-// import type * as Arken from '@arken/types';
-// import { isDebug, log } from '@arken/util';
+// import type * as Arken from '@arken/node/types';
+// import { isDebug, log } from '@arken/node/util';
 // import * as dotenv from 'dotenv';
-// import { catchExceptions, subProcesses } from '@arken/process';
+// import { catchExceptions, subProcesses } from '@arken/node/process';
 // import fetch from 'node-fetch';
 
 // import path from 'path';
 // import jetpack, { find } from 'fs-jetpack';
 // import beautify from 'json-beautify';
-// import { fancyTimeFormat } from '@arken/time';
+// import { fancyTimeFormat } from '@arken/node/time';
 // import md5 from 'js-md5';
 // import { getClientSocket } from '@arken/websocket';
-// import { isValidRequest, getSignedRequest } from '@arken/web3';
-// import getUsername from '@arken/legacy/getOldUsername';
+// import { isValidRequest, getSignedRequest } from '@arken/node/web3';
+// import getUsername from '@arken/node/legacy/getOldUsername';
 // import { z } from 'zod';
 
 // export async function monitorEvolutionRealms(app) {}

package/infinite/infinite.schema.ts

@@ -1 +1 @@
-import { z, ObjectId, Entity } from '@arken/schema';
+import { z, ObjectId, Entity } from '@arken/node/schema';

package/infinite/infinite.types.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Model, Document } from '@arken/mongo';
+import { Model, Document } from '@arken/node/mongo';
 import * as schema from './infinite.schema';
 
 export type * from './infinite.router';

package/interface/index.ts

@@ -0,0 +1,5 @@
+export * as Types from './interface.types';
+export * as Models from './interface.models';
+export * as Schemas from './interface.schema';
+export * from './interface.router';
+export * from './interface.service';

package/interface/interface.canonicalize.ts

@@ -0,0 +1,279 @@
+import get from 'lodash/get';
+
+type AnyObj = Record<string, any>;
+
+// --- same sugar compilation as web (keep it identical across runtimes) ---
+function isObject(x: any) {
+  return !!x && typeof x === 'object' && !Array.isArray(x);
+}
+function isSugarExpr(x: any) {
+  return isObject(x) && '$' in x;
+}
+function isJsonLogicExpr(x: any) {
+  return isObject(x) && '$expr' in x;
+}
+
+function sugarArgToLogic(arg: any): any {
+  if (typeof arg === 'string' && arg.startsWith('$')) return { var: arg.slice(1) };
+  return arg;
+}
+
+export function compileSugarToJsonLogic(expr: any): any {
+  if (!isSugarExpr(expr)) return expr;
+
+  const raw = expr.$;
+  if (!Array.isArray(raw) || raw.length === 0) return { $expr: raw };
+
+  const [op, ...rest] = raw;
+  const args = rest.map(sugarArgToLogic);
+
+  const map: Record<string, (a: any[]) => any> = {
+    var: (a) => ({ var: a[0] }),
+    not: (a) => ({ '!': [a[0]] }),
+    and: (a) => ({ and: a }),
+    or: (a) => ({ or: a }),
+    eq: (a) => ({ '==': [a[0], a[1]] }),
+    ne: (a) => ({ '!=': [a[0], a[1]] }),
+    gt: (a) => ({ '>': [a[0], a[1]] }),
+    gte: (a) => ({ '>=': [a[0], a[1]] }),
+    lt: (a) => ({ '<': [a[0], a[1]] }),
+    lte: (a) => ({ '<=': [a[0], a[1]] }),
+    cat: (a) => ({ cat: a }),
+    if: (a) => ({ if: a }),
+  };
+
+  const fn = map[String(op)];
+  const compiled = fn ? fn(args) : { [String(op)]: args };
+  return { $expr: compiled };
+}
+
+// --- template-to-jsonlogic compiler (same logic as web) ---
+function isTemplateString(s: any) {
+  return typeof s === 'string' && s.includes('{{') && s.includes('}}');
+}
+function isSingleMustacheWholeString(s: string) {
+  const t = s.trim();
+  return t.startsWith('{{') && t.endsWith('}}') && t.indexOf('{{') === 0 && t.lastIndexOf('}}') === t.length - 2;
+}
+
+function parseInlineArgs(raw: string): string[] {
+  const out: string[] = [];
+  let buf = '';
+  let depth = 0;
+  let quote: "'" | '"' | null = null;
+
+  const push = () => {
+    const s = buf.trim();
+    if (s) out.push(s);
+    buf = '';
+  };
+
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+
+    if (quote) {
+      buf += ch;
+      if (ch === quote && raw[i - 1] !== '\\') quote = null;
+      continue;
+    }
+
+    if (ch === '"' || ch === "'") {
+      quote = ch as any;
+      buf += ch;
+      continue;
+    }
+
+    if (ch === '(') depth++;
+    if (ch === ')') depth = Math.max(0, depth - 1);
+
+    if (ch === ',' && depth === 0) {
+      push();
+      continue;
+    }
+
+    buf += ch;
+  }
+
+  push();
+  return out;
+}
+
+function parseLiteralOrVar(token: string): any {
+  const t = token.trim();
+
+  if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+    try {
+      if (t.startsWith("'")) return JSON.parse('"' + t.slice(1, -1).replace(/"/g, '\\"') + '"');
+      return JSON.parse(t);
+    } catch {
+      return t.slice(1, -1);
+    }
+  }
+
+  if (t === 'true') return true;
+  if (t === 'false') return false;
+  if (t === 'null') return null;
+
+  if (/^-?\d+(\.\d+)?$/.test(t)) return Number(t);
+
+  return { var: t };
+}
+
+function compileInlineMustacheToJsonLogic(expr: string): any {
+  const s = expr.trim();
+
+  if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[[0-9]+\])*$/.test(s)) {
+    return { var: s };
+  }
+
+  const m = /^([A-Za-z_$][\w$]*)\(([\s\S]*)\)$/.exec(s);
+  if (!m) return { var: s };
+
+  const fn = m[1];
+  const argRaw = m[2] ?? '';
+  const argTokens = parseInlineArgs(argRaw);
+  const args = argTokens.map(parseLiteralOrVar);
+
+  const map: Record<string, any> = {
+    not: (a: any[]) => ({ '!': [a[0]] }),
+    and: (a: any[]) => ({ and: a }),
+    or: (a: any[]) => ({ or: a }),
+
+    eq: (a: any[]) => ({ '==': [a[0], a[1]] }),
+    ne: (a: any[]) => ({ '!=': [a[0], a[1]] }),
+    gt: (a: any[]) => ({ '>': [a[0], a[1]] }),
+    gte: (a: any[]) => ({ '>=': [a[0], a[1]] }),
+    lt: (a: any[]) => ({ '<': [a[0], a[1]] }),
+    lte: (a: any[]) => ({ '<=': [a[0], a[1]] }),
+
+    cat: (a: any[]) => ({ cat: a }),
+    if: (a: any[]) => ({ if: a }),
+  };
+
+  const builder = map[fn];
+  if (builder) return builder(args);
+
+  return { [fn]: args };
+}
+
+function compileInterpolatedStringToCat(s: string): any {
+  const parts: any[] = [];
+  let i = 0;
+
+  while (i < s.length) {
+    const start = s.indexOf('{{', i);
+    if (start === -1) {
+      const tail = s.slice(i);
+      if (tail) parts.push(tail);
+      break;
+    }
+
+    const head = s.slice(i, start);
+    if (head) parts.push(head);
+
+    const end = s.indexOf('}}', start + 2);
+    if (end === -1) {
+      parts.push(s.slice(start));
+      break;
+    }
+
+    const inner = s.slice(start + 2, end);
+    parts.push(compileInlineMustacheToJsonLogic(inner));
+
+    i = end + 2;
+  }
+
+  if (parts.length === 1) return parts[0];
+  return { cat: parts };
+}
+
+function compileTemplateStringToJsonLogicValue(input: string): any {
+  let out = String(input);
+
+  const ifRe = /{{#if\s+([^}]+)}}([\s\S]*?)({{else}}([\s\S]*?))?{{\/if}}/g;
+
+  for (let loop = 0; loop < 10; loop++) {
+    const prev = out;
+    out = out.replace(ifRe, (_m, condRaw, thenPart, _elseWhole, elsePart) => {
+      const cond = String(condRaw ?? '').trim();
+      const thenS = String(thenPart ?? '');
+      const elseS = String(elsePart ?? '');
+      return `__IF__(${cond})__THEN__(${thenS})__ELSE__(${elseS})__END__`;
+    });
+    if (out === prev) break;
+  }
+
+  const ifSentinelRe = /^__IF__\(([\s\S]*)\)__THEN__\(([\s\S]*)\)__ELSE__\(([\s\S]*)\)__END__$/;
+  const mm = ifSentinelRe.exec(out);
+  if (mm) {
+    const condExpr = compileInlineMustacheToJsonLogic(mm[1]);
+    const thenCompiled = compileTemplateStringToJsonLogicValue(mm[2]);
+    const elseCompiled = compileTemplateStringToJsonLogicValue(mm[3]);
+    return { if: [condExpr, thenCompiled, elseCompiled] };
+  }
+
+  if (isSingleMustacheWholeString(out) && !out.includes('{{#if')) {
+    const inner = out.trim().slice(2, -2);
+    return compileInlineMustacheToJsonLogic(inner);
+  }
+
+  if (out.includes('{{')) {
+    return compileInterpolatedStringToCat(out);
+  }
+
+  return out;
+}
+
+function compileTemplateStringToExpr(s: string) {
+  if (!isTemplateString(s)) return s;
+  const compiled = compileTemplateStringToJsonLogicValue(s);
+  if (compiled && typeof compiled === 'object') return { $expr: compiled };
+  return compiled;
+}
+
+// --- canonicalize: walk any JSON-ish tree and rewrite templates/sugar into $expr ---
+export function canonicalizeInterfaceDoc(input: any): any {
+  const seen = new Map<any, any>();
+
+  const walk = (v: any): any => {
+    if (v === null || v === undefined) return v;
+    if (typeof v === 'number' || typeof v === 'boolean') return v;
+
+    // IMPORTANT: Seer canonicalization should NOT preserve functions (DB-safe only)
+    if (typeof v === 'function') return undefined;
+
+    if (typeof v === 'string') {
+      // forbid legacy JS formulas at the canonical layer
+      if (v.trim().startsWith('=')) {
+        // best practice: reject, but you can also keep as-is if you must
+        throw new Error('Canonical interface spec cannot contain legacy "=..." formulas.');
+      }
+      if (isTemplateString(v)) return walk(compileTemplateStringToExpr(v));
+      return v;
+    }
+
+    if (Array.isArray(v)) return v.map(walk);
+
+    if (typeof v === 'object') {
+      if (seen.has(v)) return seen.get(v);
+
+      // sugar -> $expr
+      if (isSugarExpr(v)) return walk(compileSugarToJsonLogic(v));
+
+      // already $expr: canonicalize inside it too (deep)
+      if (isJsonLogicExpr(v)) {
+        const out = { $expr: walk((v as any).$expr) };
+        return out;
+      }
+
+      const out: AnyObj = {};
+      seen.set(v, out);
+      for (const [k, val] of Object.entries(v)) out[k] = walk(val);
+      return out;
+    }
+
+    return v;
+  };
+
+  return walk(input);
+}

package/interface/interface.models.ts

@@ -0,0 +1,40 @@
+// arken/packages/node/modules/interface/interface.models.ts
+//
+import * as mongo from '../../util/mongo';
+import type * as Types from './interface.types';
+
+export const Interface = mongo.createModel<Types.InterfaceDocument>('Interface', {
+  key: { type: String, required: true },
+  submissions: [{ type: mongo.Schema.Types.ObjectId, ref: 'InterfaceSubmission' }],
+  groupId: { type: mongo.Schema.Types.ObjectId, ref: 'InterfaceGroup', required: true },
+
+  status: {
+    type: String,
+    default: 'Active',
+    enum: ['Paused', 'Pending', 'Active', 'Archived', 'Published', 'Draft'],
+  },
+
+  // ✅ NEW (typed-wrapper-safe): store as Mixed, validate via Zod on IO
+  inherits: { type: mongo.Schema.Types.Mixed, default: [] }, // string[]
+  variables: { type: mongo.Schema.Types.Mixed, default: {} }, // record
+  patches: { type: mongo.Schema.Types.Mixed, default: [] }, // patch[]
+
+  nodes: { type: mongo.Schema.Types.Mixed, default: [] },
+  version: { type: Number },
+});
+
+export const InterfaceGroup = mongo.createModel<Types.InterfaceGroupDocument>('InterfaceGroup', {});
+
+export const InterfaceComponent = mongo.createModel<Types.InterfaceComponentDocument>('InterfaceComponent', {
+  value: { type: Object, default: {} },
+  type: { type: String },
+  hasAttachment: { type: Boolean },
+  hasValidation: { type: Boolean },
+  isDisabled: { type: Boolean },
+  isEditable: { type: Boolean },
+  isRequired: { type: Boolean },
+});
+
+export const InterfaceSubmission = mongo.createModel<Types.InterfaceSubmissionDocument>('InterfaceSubmission', {
+  interfaceId: { type: mongo.Schema.Types.ObjectId, ref: 'Interface' } as any,
+});

package/interface/interface.router.ts

@@ -0,0 +1,175 @@
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '../../util/rpc';
+import type { RouterContext } from '../../types';
+import { Interface, InterfaceGroup, InterfaceComponent } from './interface.schema';
+import { Query, getQueryInput, getQueryOutput, inferRouterOutputs } from '../../schema';
+
+export const z = zod;
+export const t = initTRPC.context<RouterContext>().create();
+export const router = t.router;
+export const procedure = t.procedure;
+
+export const createRouter = () =>
+  router({
+    // Interface Procedures
+    getInterface: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      .output(Interface)
+      .query(({ input, ctx }) => (ctx.app.service.Interface.getInterface as any)(input, ctx)),
+
+    createInterface: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      .output(Interface.pick({ id: true, name: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.createInterface as any)(input, ctx)),
+
+    updateInterface: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      .output(Interface.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.updateInterface as any)(input, ctx)),
+
+    deleteInterface: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      // .output(Interface.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.deleteInterface as any)(input, ctx)),
+
+    getInterfaces: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      .output(z.object({ items: z.array(Interface), total: z.number() }))
+      .query(({ input, ctx }) => (ctx.app.service.Interface.getInterfaces as any)(input, ctx)),
+
+    // getInterface: procedure
+    //   .use(hasRole('guest', t))
+    //   .use(customErrorFormatter(t))
+    //   .input(getQueryInput(Interface))
+    //   .output(Interface)
+    //   .query(({ input, ctx }) => (ctx.app.service.Interface.getInterface as any)(input, ctx)),
+
+    // getInterfaces: procedure
+    //   .use(hasRole('guest', t))
+    //   .use(customErrorFormatter(t))
+    //   .input(getQueryInput(Interface))
+    //   .output(z.array(Interface))
+    //   .query(({ input, ctx }) => (ctx.app.service.Interface.getInterfaces as any)(input, ctx)),
+
+    // createInterface: procedure
+    //   .use(hasRole('admin', t))
+    //   .use(customErrorFormatter(t))
+    //   .input(getQueryInput(Interface))
+    //   .output(Interface.pick({ id: true }))
+    //   .mutation(({ input, ctx }) => (ctx.app.service.Interface.createInterface as any)(input, ctx)),
+
+    // updateInterface: procedure
+    //   .use(hasRole('admin', t))
+    //   .use(customErrorFormatter(t))
+    //   .input(getQueryInput(Interface))
+    //   .output(Interface.pick({ id: true }))
+    //   .mutation(({ input, ctx }) => (ctx.app.service.Interface.updateInterface as any)(input, ctx)),
+
+    // deleteInterface: procedure
+    //   .use(hasRole('admin', t))
+    //   .use(customErrorFormatter(t))
+    //   .input(getQueryInput(Interface))
+    //   .output(Interface.pick({ id: true }))
+    //   .mutation(({ input, ctx }) => (ctx.app.service.Interface.deleteInterface as any)(input, ctx)),
+
+    // InterfaceGroup Procedures
+    getInterfaceGroup: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(InterfaceGroup))
+      .output(InterfaceGroup)
+      .query(({ input, ctx }) => (ctx.app.service.Interface.getInterfaceGroup as any)(input, ctx)),
+
+    getInterfaceGroups: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(InterfaceGroup))
+      .output(z.array(InterfaceGroup))
+      .query(({ input, ctx }) => (ctx.app.service.Interface.getInterfaceGroups as any)(input, ctx)),
+
+    createInterfaceGroup: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(InterfaceGroup))
+      .output(InterfaceGroup.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.createInterfaceGroup as any)(input, ctx)),
+
+    updateInterfaceGroup: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(InterfaceGroup))
+      .output(InterfaceGroup.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.updateInterfaceGroup as any)(input, ctx)),
+
+    // InterfaceComponent Procedures
+    getInterfaceComponent: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(InterfaceComponent))
+      .output(InterfaceComponent)
+      .query(({ input, ctx }) => (ctx.app.service.Interface.getInterfaceComponent as any)(input, ctx)),
+
+    createInterfaceComponent: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(InterfaceComponent))
+      .output(InterfaceComponent.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.createInterfaceComponent as any)(input, ctx)),
+
+    updateInterfaceComponent: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(InterfaceComponent))
+      .output(InterfaceComponent.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.updateInterfaceComponent as any)(input, ctx)),
+
+    publishInterface: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      .output(Interface.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.updateInterfaceComponent as any)(input, ctx)),
+
+    deactivateInterface: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      .output(Interface.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.updateInterfaceComponent as any)(input, ctx)),
+
+    resetInterface: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      .output(Interface.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.updateInterfaceComponent as any)(input, ctx)),
+
+    acceptInterfaceSubmission: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      .output(Interface.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.updateInterfaceComponent as any)(input, ctx)),
+
+    createInterfaceDraft: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Interface))
+      .output(Interface.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Interface.createInterfaceDraft as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/interface/interface.schema.ts

@@ -0,0 +1,59 @@
+// arken/packages/node/modules/interface/interface.schema.ts
+//
+import { z, ObjectId, Entity } from '../../schema';
+
+// Patch ops for interface composition
+const InterfacePatch = z.object({
+  op: z.enum(['merge', 'replace', 'remove', 'push', 'unshift', 'splice']).default('merge'),
+  key: z.string().min(1), // target node key (or special key like "root")
+  path: z.string().optional(), // optional deep path inside that node, ex: "props.omit"
+  value: z.unknown().optional(), // payload for merge/replace/push/etc
+});
+
+export const Interface = Entity.merge(
+  z.object({
+    ratingId: ObjectId.optional(),
+    groupId: ObjectId.optional(),
+    submissions: z.array(ObjectId).optional(),
+
+    // ✅ NEW: composition / inheritance
+    inherits: z.array(z.string()).default([]),
+
+    // ✅ NEW: variables available to formula scope + patch engine
+    variables: z.record(z.unknown()).default({}),
+
+    // ✅ NEW: patch list applied on top of inherited/base nodes
+    patches: z.array(InterfacePatch).default([]),
+
+    // existing
+    nodes: z.any(), // you can later tighten this to z.array(AnyNodeSchema)
+    version: z.number().optional(),
+    status: z.enum(['Paused', 'Pending', 'Active', 'Archived', 'Published', 'Draft']).default('Active'),
+  })
+);
+
+export const InterfaceGroup = Entity.merge(
+  z.object({
+    roles: z.array(ObjectId).optional(),
+  })
+);
+
+export const InterfaceComponent = Entity.merge(
+  z.object({
+    value: z.unknown().optional(),
+    data: z.record(z.unknown()).optional(),
+    type: z.string().optional(),
+    hasAttachment: z.boolean().optional(),
+    hasValidation: z.boolean().optional(),
+    isDisabled: z.boolean().optional(),
+    isEditable: z.boolean().optional(),
+    isRequired: z.boolean().optional(),
+  })
+);
+
+export const InterfaceSubmission = Entity.merge(
+  z.object({
+    interfaceId: ObjectId,
+    interface: ObjectId.optional(),
+  })
+);

package/interface/interface.types.ts

@@ -0,0 +1,25 @@
+import { z, Model, Document } from '../../util/mongo';
+import * as schema from './interface.schema';
+
+export type * from './interface.router';
+export type * from './interface.service';
+export type { RouterContext } from '../../types';
+
+export type Interface = z.infer<typeof schema.Interface>;
+export type InterfaceDocument = Interface & Document;
+
+export type InterfaceGroup = z.infer<typeof schema.InterfaceGroup>;
+export type InterfaceGroupDocument = InterfaceGroup & Document;
+
+export type InterfaceComponent = z.infer<typeof schema.InterfaceComponent>;
+export type InterfaceComponentDocument = InterfaceComponent & Document;
+
+export type InterfaceSubmission = z.infer<typeof schema.InterfaceSubmission>;
+export type InterfaceSubmissionDocument = InterfaceSubmission & Document;
+
+export type Mappings = {
+  Interface: Model<InterfaceDocument>;
+  InterfaceGroup: Model<InterfaceGroupDocument>;
+  InterfaceComponent: Model<InterfaceComponentDocument>;
+  InterfaceSubmission: Model<InterfaceSubmissionDocument>;
+};

package/isles/isles.models.ts

@@ -1,3 +1,3 @@
-import * as mongo from '@arken/mongo';
+import * as mongo from '@arken/node/mongo';
 
 const { addTagVirtuals, addApplicationVirtual } = mongo;

package/isles/isles.router.ts

@@ -1,8 +1,8 @@
 import { z as zod } from 'zod';
 import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '@arken/rpc';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
 import * as Arken from '@arken/node';
-import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/schema';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/node/schema';
 import { RouterContext } from '../../types';
 
 export const z = zod;
@@ -1316,20 +1316,20 @@ export type RouterOutput = inferRouterOutputs<Router>;
 //     }
 //   });
 
-// import type * as Arken from '@arken/types';
-// import { isDebug, log } from '@arken/util';
+// import type * as Arken from '@arken/node/types';
+// import { isDebug, log } from '@arken/node/util';
 // import * as dotenv from 'dotenv';
-// import { catchExceptions, subProcesses } from '@arken/process';
+// import { catchExceptions, subProcesses } from '@arken/node/process';
 // import fetch from 'node-fetch';
 
 // import path from 'path';
 // import jetpack, { find } from 'fs-jetpack';
 // import beautify from 'json-beautify';
-// import { fancyTimeFormat } from '@arken/time';
+// import { fancyTimeFormat } from '@arken/node/time';
 // import md5 from 'js-md5';
 // import { getClientSocket } from '@arken/websocket';
-// import { isValidRequest, getSignedRequest } from '@arken/web3';
-// import getUsername from '@arken/legacy/getOldUsername';
+// import { isValidRequest, getSignedRequest } from '@arken/node/web3';
+// import getUsername from '@arken/node/legacy/getOldUsername';
 // import { z } from 'zod';
 
 // export async function monitorEvolutionRealms(app) {}