@arken/node 1.5.0 → 1.5.2

package/modules/game/game.service.ts

@@ -1,143 +0,0 @@
-import type { RouterContext, RouterInput, RouterOutput, Era, Game, GameStat } from './game.types';
-import { getFilter } from '../../util/api';
-import { ARXError } from '../../util/rpc';
-
-export class Service {
-  // Game Methods
-  async getGame(input: RouterInput['getGame'], ctx: RouterContext): Promise<RouterOutput['getGame']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Core.Service.getGame', input, getFilter(input));
-
-    const game = await ctx.app.model.Game.findOne(getFilter(input)).populate('stat').exec();
-
-    if (!game) throw new Error('Game not found');
-
-    return game as Game;
-  }
-
-  async getGames(input: RouterInput['getGames'], ctx: RouterContext): Promise<RouterOutput['getGames']> {
-    console.log('Core.Service.getGames', input);
-
-    const filter = getFilter(input);
-
-    filter.status = 'Active';
-
-    const games = await ctx.app.model.Game.find(filter).populate('stat').exec();
-
-    return games as Game[];
-  }
-
-  async createGame(input: RouterInput['createGame'], ctx: RouterContext): Promise<RouterOutput['createGame']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Core.Service.createGame', input);
-
-    const game = await ctx.app.model.Game.create(input);
-    return game as Game;
-  }
-
-  async updateGame(input: RouterInput['updateGame'], ctx: RouterContext): Promise<RouterOutput['updateGame']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Core.Service.updateGame', input);
-
-    const filter = getFilter(input);
-    const updatedGame = await ctx.app.model.Game.findByIdAndUpdate(filter.id, { new: true }).lean().exec();
-    if (!updatedGame) throw new Error('Game update failed');
-
-    return updatedGame as Game;
-  }
-
-  // GameStat Methods
-  async getGameStat(input: RouterInput['getGameStat'], ctx: RouterContext): Promise<RouterOutput['getGameStat']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Core.Service.getGameStat', input);
-
-    const gameStat = await ctx.app.model.GameStat.findOne(getFilter(input)).exec();
-    if (!gameStat) throw new Error('GameStat not found');
-
-    return gameStat as GameStat;
-  }
-
-  async getGameStats(input: RouterInput['getGameStats'], ctx: RouterContext): Promise<RouterOutput['getGameStats']> {
-    console.log('Core.Service.getGameStats', input);
-
-    const filter = getFilter(input);
-
-    filter.status = 'Active';
-
-    const gameStats = await ctx.app.model.GameStat.find(filter).exec();
-
-    return gameStats as GameStat[];
-  }
-
-  async createGameStat(
-    input: RouterInput['createGameStat'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createGameStat']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Core.Service.createGameStat', input);
-
-    const gameStat = await ctx.app.model.GameStat.create(input);
-    return gameStat as GameStat;
-  }
-
-  async updateGameStat(
-    input: RouterInput['updateGameStat'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateGameStat']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Core.Service.updateGameStat', input);
-
-    const gameStat = await ctx.app.model.GameStat.findByIdAndUpdate(input.where.id.equals, { new: true }).lean().exec();
-    if (!gameStat) throw new Error('GameStat update failed');
-
-    return gameStat as GameStat;
-  }
-
-  // Era Methods
-  async getEra(input: RouterInput['getEra'], ctx: RouterContext): Promise<RouterOutput['getEra']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Core.Service.getEra', input);
-
-    const era = await ctx.app.model.Era.findOne(getFilter(input)).exec();
-    if (!era) throw new Error('Era not found');
-
-    return era as Era;
-  }
-
-  async getEras(input: RouterInput['getEras'], ctx: RouterContext): Promise<RouterOutput['getEras']> {
-    const filter = getFilter(input);
-    const eras = await ctx.app.model.Era.find(filter).exec();
-
-    return eras as Era[];
-  }
-
-  async createEra(input: RouterInput['createEra'], ctx: RouterContext): Promise<RouterOutput['createEra']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Game.Service.createEra', input);
-
-    const era = await ctx.app.model.Era.create(input.data);
-    return era as Era;
-  }
-
-  async updateEra(input: RouterInput['updateEra'], ctx: RouterContext): Promise<RouterOutput['updateEra']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Game.Service.updateEra', input, input.data);
-
-    const filter = getFilter(input);
-    const updatedEra = await ctx.app.model.Era.findOneAndUpdate(filter, input.data, { new: true }).exec();
-    if (!updatedEra) throw new Error('Era update failed');
-
-    return updatedEra as Era;
-  }
-
-  async deleteEra(input: RouterInput['deleteEra'], ctx: RouterContext): Promise<RouterOutput['deleteEra']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Game.Service.deleteEra', input);
-
-    const filter = getFilter(input);
-    const deletedEra = await ctx.app.model.Era.findOneAndDelete(filter).exec();
-    if (!deletedEra) throw new Error('Era not found');
-
-    return deletedEra as Era;
-  }
-}

package/modules/game/game.types.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { Model, Document } from '../../util/mongo';
-import * as schema from './game.schema';
-
-export type * from './game.router';
-export type * from './game.service';
-export type { RouterContext } from '../../types';
-
-// Define types based on the schema
-export type Game = z.infer<typeof schema.Game>;
-export type GameDocument = Game & Document;
-
-export type GameStat = z.infer<typeof schema.GameStat>;
-export type GameStatDocument = GameStat & Document;
-
-export type GameRound = z.infer<typeof schema.GameRound>;
-export type GameRoundDocument = GameRound & Document;
-
-export type Era = z.infer<typeof schema.Era>;
-export type EraDocument = Era & Document;
-
-// Mappings for MongoDB models
-export type Mappings = {
-  Game: Model<GameDocument>;
-  GameStat: Model<GameStatDocument>;
-  GameRound: Model<GameRoundDocument>;
-  Era: Model<EraDocument>;
-};

package/modules/game/index.ts

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

package/modules/interface/index.ts

@@ -1,5 +0,0 @@
-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/modules/interface/interface.canonicalize.ts

@@ -1,279 +0,0 @@
-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/modules/interface/interface.models.ts

@@ -1,40 +0,0 @@
-// 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/modules/interface/interface.router.ts

@@ -1,175 +0,0 @@
-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>;