@arken/seer-protocol 0.1.1 → 0.1.3

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,24 @@
+import { z, Model, Document } from '@arken/node/mongo';
+import * as schema from './interface.schema';
+
+export type * from './interface.router';
+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/index.ts

@@ -2,4 +2,3 @@ export type * as Types from './isles.types';
 export * as Models from './isles.models';
 export * as Schemas from './isles.schema';
 export * from './isles.router';
-export * from './isles.service';

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,9 +1,9 @@
 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 { RouterContext } from '../../types';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/node/schema';
+import { RouterContext } from '../types';
 
 export const z = zod;
 export const t = initTRPC.context<RouterContext>().create();
@@ -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/isles/isles.schema.ts

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

package/isles/isles.types.ts

@@ -1,10 +1,9 @@
 import { z } from 'zod';
-import { Model, Document } from '@arken/mongo';
+import { Model, Document } from '@arken/node/mongo';
 import * as schema from './isles.schema';
 
 export type * from './isles.router';
-export type * from './isles.service';
-export type { RouterContext } from '../../types';
+export type { RouterContext } from '../types';
 
 // // Define types based on the schema
 // export type Game = z.infer<typeof schema.Game>;

package/item/index.ts

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

package/item/item.models.ts

@@ -0,0 +1,124 @@
+import * as mongo from '@arken/node/mongo';
+import type * as Types from './item.types';
+
+const { addTagVirtuals, addApplicationVirtual } = mongo;
+
+export const Item = mongo.createModel<Types.ItemDocument>(
+  'Item',
+  {
+    token: { type: String, maxlength: 500, minlength: 1, required: true },
+    characterId: { type: mongo.Schema.Types.ObjectId, ref: 'Character', required: true },
+    assetId: { type: mongo.Schema.Types.ObjectId, ref: 'Asset', required: true },
+    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain', required: false },
+    materialId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemMaterial', required: false },
+    skinId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSkin', required: false },
+    recipeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemRecipe', required: false },
+    typeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemType', required: false },
+    subTypeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSubType', required: false },
+    specificTypeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSpecificType', required: false },
+    rarityId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemRarity', required: false },
+    rankId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemRank', required: false },
+    rankValue: { type: Number, integer: true, min: 0, max: 100, required: false },
+    slotIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemSlot', required: false }],
+    setId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSet', required: false },
+    attributes: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemAttribute', required: false }],
+    quantity: { type: Number, integer: true, min: 0, default: 1 },
+    distribution: { type: String, default: 'Unknown' },
+    x: { type: Number, integer: true, min: 0, required: false },
+    y: { type: Number, integer: true, min: 0, required: false },
+    items: [{ type: mongo.Schema.Types.ObjectId, ref: 'Item', default: [] }],
+    capacity: { type: Number, integer: true, min: 0, default: 60 },
+    points: { type: Number, integer: true, min: 0, default: 0 },
+  },
+  {
+    extend: 'EntityFields',
+    indexes: [{ quantity: 1 }, { points: 1 }, { capacity: 1 }],
+    virtuals: [
+      ...addTagVirtuals('Item'),
+      ...addApplicationVirtual(),
+      {
+        name: 'character',
+      },
+      {
+        name: 'asset',
+      },
+      {
+        name: 'chain',
+      },
+      {
+        name: 'material',
+      },
+      {
+        name: 'skin',
+      },
+      {
+        name: 'recipe',
+      },
+      {
+        name: 'type',
+      },
+      {
+        name: 'subType',
+      },
+      {
+        name: 'specificType',
+      },
+      {
+        name: 'rarity',
+      },
+    ],
+  }
+);
+
+export const ItemAttribute = mongo.createModel<Types.ItemAttributeDocument>('ItemAttribute', {});
+
+export const ItemMaterial = mongo.createModel<Types.ItemMaterialDocument>('ItemMaterial', {});
+
+export const ItemSet = mongo.createModel<Types.ItemSetDocument>('ItemSet', {});
+
+export const ItemSlot = mongo.createModel<Types.ItemSlotDocument>('ItemSlot', {});
+
+export const ItemRarity = mongo.createModel<Types.ItemRarityDocument>('ItemRarity', {});
+
+export const ItemRank = mongo.createModel<Types.ItemRankDocument>('ItemRank', {
+  value: { type: Number },
+});
+
+export const ItemType = mongo.createModel<Types.ItemTypeDocument>('ItemType', {});
+
+export const ItemSubType = mongo.createModel<Types.ItemSubTypeDocument>('ItemSubType', {});
+
+export const ItemSpecificType = mongo.createModel<Types.ItemSpecificTypeDocument>('ItemSpecificType', {});
+
+export const ItemAffix = mongo.createModel<Types.ItemAffixDocument>('ItemAffix', {
+  isPrefix: { type: Boolean, default: false },
+  isSuffix: { type: Boolean, default: false },
+  isTitle: { type: Boolean, default: false },
+  weight: { type: Number, min: 0, default: 1 },
+  typeIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemType', required: false }],
+  rarityIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemRarity', required: false }],
+});
+
+export const ItemRecipe = mongo.createModel<Types.ItemRecipeDocument>('ItemRecipe', {});
+
+export const ItemSkin = mongo.createModel<Types.ItemSkinDocument>('ItemSkin', {});
+
+export const ItemTransmute = mongo.createModel<Types.ItemTransmuteDocument>(
+  'ItemTransmute',
+  {
+    token: { type: String, maxlength: 500, required: true },
+    assetId: { type: mongo.Schema.Types.ObjectId, ref: 'Asset', required: true },
+    itemId: { type: mongo.Schema.Types.ObjectId, ref: 'Item', required: true },
+    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain' },
+  },
+  {
+    virtuals: [
+      {
+        name: 'item',
+      },
+      {
+        name: 'asset',
+      },
+    ],
+  }
+);

package/item/item.router.ts

@@ -0,0 +1,103 @@
+import { z as zod } from 'zod';
+import { initTRPC } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import type { RouterContext } from '../types';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '../schema';
+import {
+  Item,
+  ItemAttribute,
+  ItemMaterial,
+  ItemSet,
+  ItemSlot,
+  ItemRarity,
+  ItemType,
+  ItemSubType,
+  ItemSpecificType,
+  ItemAffix,
+  ItemRecipe,
+  ItemSkin,
+  ItemTransmute,
+} from './item.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({
+    getItem: procedure
+      .use(hasRole('guest', t))
+      .input(getQueryInput(Item))
+      .output(Item)
+      .query(({ input, ctx }) => (ctx.app.service.Item.getItem as any)(input, ctx)),
+
+    getItems: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Item))
+      // .output(z.array(Item))
+      .query(({ input, ctx }) => (ctx.app.service.Item.getItems as any)(input, ctx)),
+
+    createItem: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Item))
+      .output(Item.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.createItem as any)(input, ctx)),
+
+    updateItem: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Item))
+      .output(Item.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.updateItem as any)(input, ctx)),
+
+    getItemAttribute: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemAttribute))
+      .output(ItemAttribute)
+      .query(({ input, ctx }) => (ctx.app.service.Item.getItemAttribute as any)(input, ctx)),
+
+    createItemAttribute: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemAttribute))
+      .output(ItemAttribute.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.createItemAttribute as any)(input, ctx)),
+
+    updateItemAttribute: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemAttribute))
+      .output(ItemAttribute.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.updateItemAttribute as any)(input, ctx)),
+
+    // Add more procedures for other entities like ItemMaterial, ItemSet, ItemSlot, ItemRarity, etc.
+
+    getItemTransmute: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemTransmute))
+      .output(ItemTransmute)
+      .query(({ input, ctx }) => (ctx.app.service.Item.getItemTransmute as any)(input, ctx)),
+
+    createItemTransmute: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemTransmute))
+      .output(ItemTransmute.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.createItemTransmute as any)(input, ctx)),
+
+    updateItemTransmute: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemTransmute))
+      .output(ItemTransmute.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.updateItemTransmute as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/item/item.schema.ts

@@ -0,0 +1,150 @@
+import { z, ObjectId, Entity } from '../schema';
+
+export const ItemAttribute = Entity.merge(
+  z.object({
+    // Define fields for ItemAttribute here if needed
+  })
+);
+
+export const ItemMaterial = Entity.merge(
+  z.object({
+    // Define fields for ItemMaterial here if needed
+  })
+);
+
+export const ItemSet = Entity.merge(
+  z.object({
+    // Define fields for ItemSet here if needed
+  })
+);
+
+export const ItemSlot = Entity.merge(
+  z.object({
+    // Define fields for ItemSlot here if needed
+  })
+);
+
+export const ItemRarity = Entity.merge(
+  z.object({
+    // Define fields for ItemRarity here if needed
+  })
+);
+
+export const ItemRank = Entity.merge(
+  z.object({
+    value: z.number(),
+    // Define fields for ItemRank here if needed
+  })
+);
+
+export const ItemType = Entity.merge(
+  z.object({
+    // Define fields for ItemType here if needed
+  })
+);
+
+export const ItemSubType = Entity.merge(
+  z.object({
+    // Define fields for ItemSubType here if needed
+  })
+);
+
+export const ItemSpecificType = Entity.merge(
+  z.object({
+    // Define fields for ItemSpecificType here if needed
+  })
+);
+
+export const ItemAffix = Entity.merge(
+  z.object({
+    isPrefix: z.boolean().default(false),
+    isSuffix: z.boolean().default(false),
+    isTitle: z.boolean().default(false),
+    weight: z
+      .number()
+      .min(0)
+      .default(1),
+    typeIds: z.array(ObjectId).optional(),
+    rarityIds: z.array(ObjectId).optional(),
+  })
+);
+
+export const ItemRecipe = Entity.merge(
+  z.object({
+    // Define fields for ItemRecipe here if needed
+  })
+);
+
+export const ItemSkin = Entity.merge(
+  z.object({
+    // Define fields for ItemSkin here if needed
+  })
+);
+
+export const ItemTransmute = Entity.merge(
+  z.object({
+    token: z
+      .string()
+      .max(500)
+      .min(1),
+    assetId: ObjectId,
+    itemId: ObjectId,
+    chainId: ObjectId.optional(),
+  })
+);
+
+export const Item = Entity.merge(
+  z.object({
+    characterId: ObjectId.optional(),
+    assetId: ObjectId.optional(),
+    chainId: ObjectId.optional(),
+    materialId: ItemMaterial.optional(),
+    skinId: ItemSkin.optional(),
+    recipeId: ItemRecipe.optional(),
+    typeId: ItemType.optional(),
+    subTypeId: ItemSubType.optional(),
+    specificTypeId: ItemSpecificType.optional(),
+    rankId: ItemRank.optional(),
+    rankValue: z.number(),
+    rarityId: ItemRarity.optional(),
+    slotIds: z.array(ItemSlot.optional()),
+    setId: ItemSet.optional(),
+    attributes: z.array(ItemAttribute).optional(),
+    token: z
+      .string()
+      .max(500)
+      .min(1)
+      .optional(),
+    quantity: z
+      .number()
+      .int()
+      .nonnegative()
+      .default(1),
+    x: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional(),
+    y: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional(),
+    distribution: z
+      .enum(['Unknown', 'Found', 'Fundraiser', 'Claimed', 'Crafted', 'Airdrop', 'Reward', 'Farmed', 'Migration'])
+      .default('Unknown'),
+    // properties: z.record(z.any()).optional(),
+    // type: z.string().default('bag'), // stash, bag, equipment, etc.
+    items: z.array(z.lazy(() => Item)).default([]),
+    capacity: z
+      .number()
+      .int()
+      .nonnegative()
+      .default(60),
+    points: z
+      .number()
+      .int()
+      .nonnegative()
+      .default(0),
+  })
+);

package/item/item.types.ts

@@ -0,0 +1,73 @@
+// module/item.types.ts
+
+import { z } from 'zod';
+import * as schema from './item.schema';
+import { Document, Model } from '@arken/node/mongo';
+import type { RouterContext } from '../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './item.router';
+
+export type * from './item.router';
+export type { RouterContext };
+
+export type Item = z.infer<typeof schema.Item>;
+export type ItemDocument = Item & Document;
+
+export type ItemAttribute = z.infer<typeof schema.ItemAttribute>;
+export type ItemAttributeDocument = ItemAttribute & Document;
+
+export type ItemMaterial = z.infer<typeof schema.ItemMaterial>;
+export type ItemMaterialDocument = ItemMaterial & Document;
+
+export type ItemSet = z.infer<typeof schema.ItemSet>;
+export type ItemSetDocument = ItemSet & Document;
+
+export type ItemSlot = z.infer<typeof schema.ItemSlot>;
+export type ItemSlotDocument = ItemSlot & Document;
+
+export type ItemRarity = z.infer<typeof schema.ItemRarity>;
+export type ItemRarityDocument = ItemRarity & Document;
+
+export type ItemRank = z.infer<typeof schema.ItemRank>;
+export type ItemRankDocument = ItemRank & Document;
+
+export type ItemType = z.infer<typeof schema.ItemType>;
+export type ItemTypeDocument = ItemType & Document;
+
+export type ItemSubType = z.infer<typeof schema.ItemSubType>;
+export type ItemSubTypeDocument = ItemSubType & Document;
+
+export type ItemSpecificType = z.infer<typeof schema.ItemSpecificType>;
+export type ItemSpecificTypeDocument = ItemSpecificType & Document;
+
+export type ItemAffix = z.infer<typeof schema.ItemAffix>;
+export type ItemAffixDocument = ItemAffix & Document;
+
+export type ItemRecipe = z.infer<typeof schema.ItemRecipe>;
+export type ItemRecipeDocument = ItemRecipe & Document;
+
+export type ItemSkin = z.infer<typeof schema.ItemSkin>;
+export type ItemSkinDocument = ItemSkin & Document;
+
+export type ItemTransmute = z.infer<typeof schema.ItemTransmute>;
+export type ItemTransmuteDocument = ItemTransmute & Document;
+
+export type Mappings = {
+  Item: Model<ItemDocument>;
+  ItemAttribute: Model<ItemAttributeDocument>;
+  ItemMaterial: Model<ItemMaterialDocument>;
+  ItemSet: Model<ItemSetDocument>;
+  ItemSlot: Model<ItemSlotDocument>;
+  ItemRarity: Model<ItemRarityDocument>;
+  ItemRank: Model<ItemRankDocument>;
+  ItemType: Model<ItemTypeDocument>;
+  ItemSubType: Model<ItemSubTypeDocument>;
+  ItemSpecificType: Model<ItemSpecificTypeDocument>;
+  ItemAffix: Model<ItemAffixDocument>;
+  ItemRecipe: Model<ItemRecipeDocument>;
+  ItemSkin: Model<ItemSkinDocument>;
+  ItemTransmute: Model<ItemTransmuteDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/job/index.ts

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

package/job/job.models.ts

@@ -0,0 +1,14 @@
+import * as mongo from '@arken/node/mongo';
+import type * as Types from './job.types';
+
+export const Job = mongo.createModel<Types.JobDocument>(
+  'Job',
+  {
+    mod: { type: String, required: true },
+    startDate: { type: Date },
+    expireDate: { type: Date },
+  },
+  {
+    indexes: [{ applicationId: 1, mod: 1, key: 1 }],
+  }
+);

package/job/job.router.ts

@@ -0,0 +1,44 @@
+// job.router.ts
+
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import type { RouterContext } from '../types';
+import { Job } from './job.schema';
+import { Query } 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({
+    getJob: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Job.getJob as any)(input, ctx)),
+
+    createJob: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: Job }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Job.createJob as any)(input, ctx)),
+
+    updateJob: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: Job.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Job.updateJob as any)(input, ctx)),
+
+    updateMetrics: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.any())
+      .mutation(({ input, ctx }) => (ctx.app.service.Job.updateMetrics as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;