@arken/seer-protocol 0.1.1 → 0.1.3

package/schema.ts

@@ -0,0 +1,321 @@
+// arken/packages/node/schema.ts
+//
+import Mongoose, { Types } from 'mongoose';
+import { z as zod, ZodTypeAny, ZodLazy, ZodObject, ZodArray } from 'zod';
+import { AnyProcedure, inferProcedureOutput, AnyRouter, AnyTRPCClientTypes, TRPCRouterRecord } from '@trpc/server';
+
+export type { inferRouterInputs } from '@trpc/server';
+
+export const z = zod;
+
+// @ts-ignore
+export const ObjectId = z.union([
+  z.string().refine((value) => Mongoose.isValidObjectId(value), {
+    // Accept valid ObjectId strings
+    message: 'Invalid ObjectId',
+  }),
+  z.instanceof(Types.ObjectId), // Accept Mongoose ObjectId instances
+]);
+
+export const Anything = z.any();
+export const Nothing = z.object({});
+export const Signature = z.object({ hash: z.string(), address: z.string() });
+export const UnsignedData = z.object({ data: z.any() });
+export const SignedData = z.object({
+  data: z.any(),
+  signature: Signature,
+});
+
+export const AnyInput = z.any();
+export const OnlySignatureInput = z.object({ signature: Signature });
+export const NoDataOutput = z.object({ status: z.number() });
+export const AnyDataOutput = z.object({ data: z.any(), status: z.number() });
+
+export enum Status {
+  Paused = 'Paused',
+  Pending = 'Pending',
+  Active = 'Active',
+  Archived = 'Archived',
+}
+
+export type Meta = {
+  [key: string]: unknown;
+};
+
+export const Common = z.object({
+  id: ObjectId.optional(),
+  meta: z.any(), // Default value set here matches Mongoose
+  data: z.any(), // Default value set here matches Mongoose
+  status: z.enum(['Paused', 'Pending', 'Active', 'Archived']).default('Active'), // Default set in StatusEnum matches Mongoose
+  merkleLeaf: z.string().optional(),
+  merkleIndex: z.number().optional(),
+  createdById: ObjectId.optional(),
+  editedById: ObjectId.optional(),
+  deletedById: ObjectId.optional(),
+  createdDate: z.date().default(() => new Date()), // Default matches Mongoose
+  updatedDate: z.date().optional(),
+  deletedDate: z.date().optional(),
+});
+
+export type Common = zod.infer<typeof Common>;
+
+export const Entity = z
+  .object({
+    id: z.string().min(24).max(24).trim().optional(),
+    key: z.string().min(1).max(200).trim().optional(),
+    name: z.string().min(1).max(200).trim().optional(),
+    description: z.string().optional(),
+    applicationId: ObjectId.optional(),
+    ownerId: ObjectId.optional(),
+  })
+  .merge(Common);
+
+export type Entity = zod.infer<typeof Entity>;
+
+const QueryFilterOperators = z.object({
+  equals: z.any().optional(),
+  not: z.any().optional(),
+  in: z.array(z.any()).optional(),
+  notIn: z.array(z.any()).optional(),
+  lt: z.any().optional(),
+  lte: z.any().optional(),
+  gt: z.any().optional(),
+  gte: z.any().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  mode: z.enum(['default', 'insensitive']).optional(),
+});
+
+const QueryWhereSchema = z.lazy(() =>
+  z.object({
+    AND: z.array(QueryWhereSchema).optional(),
+    OR: z.array(QueryWhereSchema).optional(),
+    NOT: z.array(QueryWhereSchema).optional(),
+    id: QueryFilterOperators.optional(),
+    key: QueryFilterOperators.optional(),
+    name: QueryFilterOperators.optional(),
+    email: QueryFilterOperators.optional(),
+    status: QueryFilterOperators.optional(),
+  })
+);
+
+export const Query = z.object({
+  skip: z.number().default(0).optional(),
+  take: z.number().default(10).optional(),
+  cursor: z.record(z.any()).optional(),
+  where: QueryWhereSchema.optional(),
+  orderBy: z.record(z.enum(['asc', 'desc'])).optional(),
+  include: z.record(z.boolean()).optional(),
+  select: z.record(z.boolean()).optional(),
+});
+
+// // Operators for filtering in a Prisma-like way
+// type PrismaFilterOperators<T extends ZodTypeAny> = zod.ZodObject<
+//   {
+//     equals?: T;
+//     not?: T;
+//     in?: zod.ZodArray<T>;
+//     notIn?: zod.ZodArray<T>;
+//     lt?: T;
+//     lte?: T;
+//     gt?: T;
+//     gte?: T;
+//     contains?: zod.ZodString; // T extends zod.ZodString ? zod.ZodString : never;
+//     startsWith?: zod.ZodString; // T extends zod.ZodString ? zod.ZodString : never;
+//     endsWith?: zod.ZodString; // T extends zod.ZodString ? zod.ZodString : never;
+//     mode?: zod.ZodString; // T extends zod.ZodString ? zod.ZodEnum<['default', 'insensitive']> : never;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 0: No AND, OR, NOT
+// type PrismaWhereLevel0<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 1: Includes AND, OR, NOT of Level 0
+// type PrismaWhereLevel1<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     AND?: ZodArray<ZodLazy<PrismaWhereLevel0<T>>>;
+//     OR?: ZodArray<ZodLazy<PrismaWhereLevel0<T>>>;
+//     NOT?: ZodArray<ZodLazy<PrismaWhereLevel0<T>>>;
+//   } & {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 2: Includes AND, OR, NOT of Level 1
+// type PrismaWhereLevel2<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     AND?: ZodArray<ZodLazy<PrismaWhereLevel1<T>>>;
+//     OR?: ZodArray<ZodLazy<PrismaWhereLevel1<T>>>;
+//     NOT?: ZodArray<ZodLazy<PrismaWhereLevel1<T>>>;
+//   } & {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 3: Includes AND, OR, NOT of Level 2
+// type PrismaWhereLevel3<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     AND?: ZodArray<ZodLazy<PrismaWhereLevel2<T>>>;
+//     OR?: ZodArray<ZodLazy<PrismaWhereLevel2<T>>>;
+//     NOT?: ZodArray<ZodLazy<PrismaWhereLevel2<T>>>;
+//   } & {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 4: Includes AND, OR, NOT of Level 3
+// type PrismaWhereLevel4<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     AND?: ZodArray<ZodLazy<PrismaWhereLevel3<T>>>;
+//     OR?: ZodArray<ZodLazy<PrismaWhereLevel3<T>>>;
+//     NOT?: ZodArray<ZodLazy<PrismaWhereLevel3<T>>>;
+//   } & {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// Function to create a recursive schema up to level 4
+export const createPrismaWhereSchema = <T extends zod.ZodRawShape>(
+  modelSchema: zod.ZodObject<T>,
+  depth: number = 3
+): zod.ZodObject<any> => {
+  const fields = modelSchema.shape;
+
+  /**
+   * For each field, accept either:
+   *   - a full operator object: { equals, in, lt, ... }
+   *   - OR a raw value shorthand: 'foo'  -> { equals: 'foo' }
+   */
+  const makeFieldFilter = (value: zod.ZodTypeAny) => {
+    const opsSchema = zod
+      .object({
+        equals: value.optional(),
+        not: value.optional(),
+        in: zod.array(value).optional(),
+        notIn: zod.array(value).optional(),
+        lt: value.optional(),
+        lte: value.optional(),
+        gt: value.optional(),
+        gte: value.optional(),
+        contains: zod.string().optional(),
+        startsWith: zod.string().optional(),
+        endsWith: zod.string().optional(),
+        mode: zod.string().optional(),
+      })
+      .partial();
+
+    return zod
+      .preprocess((input) => {
+        // let undefined through
+        if (input === undefined) return input;
+
+        // Already an object (likely { equals, in, ... }) → validate as-is
+        if (typeof input === 'object' && input !== null && !Array.isArray(input)) {
+          return input;
+        }
+
+        // Prisma-style shorthand: profileId: 'abc'  -> { equals: 'abc' }
+        return { equals: input };
+      }, opsSchema)
+      .optional();
+  };
+
+  const fieldFilters = Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, makeFieldFilter(value)]));
+
+  if (depth <= 0) {
+    // Base case: no AND/OR/NOT
+    return zod.object({
+      ...fieldFilters,
+    });
+  }
+
+  return zod.object({
+    AND: zod.array(zod.lazy(() => createPrismaWhereSchema(modelSchema, depth - 1))).optional(),
+    OR: zod.array(zod.lazy(() => createPrismaWhereSchema(modelSchema, depth - 1))).optional(),
+    NOT: zod.array(zod.lazy(() => createPrismaWhereSchema(modelSchema, depth - 1))).optional(),
+    ...fieldFilters,
+  });
+};
+
+export const getQueryOutput = <T extends zod.ZodTypeAny>(data: T) => {
+  return z.object({ status: z.number(), data: data.optional(), error: z.string().optional() });
+};
+
+export const getQueryInput = <S extends zod.ZodTypeAny>(schema: S, options: { partialData?: boolean } = {}) => {
+  const { partialData = true } = options;
+
+  // Only object schemas get "where" support.
+  const isObjectSchema = schema instanceof zod.ZodObject;
+
+  const whereSchema = isObjectSchema
+    ? createPrismaWhereSchema(schema as any) // keep your existing recursive builder
+    : zod.never(); // not used; also prevents people from sending "where" for arrays
+
+  const dataSchema = isObjectSchema
+    ? partialData
+      ? (schema as any).partial().optional()
+      : (schema as any).optional()
+    : schema.optional(); // arrays: allow full array
+
+  const querySchema = zod
+    .object({
+      data: dataSchema,
+
+      // keep your query envelope fields
+      skip: zod.number().default(0).optional(),
+      limit: zod.number().default(10).optional(),
+      cursor: zod.record(zod.any()).optional(),
+
+      // only valid for object schemas
+      where: isObjectSchema ? whereSchema.optional() : zod.undefined().optional(),
+
+      orderBy: zod.record(zod.enum(['asc', 'desc'])).optional(),
+      include: zod.record(zod.boolean()).optional(),
+      select: zod.record(zod.boolean()).optional(),
+    })
+    .partial();
+
+  return zod.union([querySchema, zod.undefined()]);
+};
+
+export type inferQuery<T extends zod.ZodRawShape> = zod.infer<ReturnType<typeof createPrismaWhereSchema<T>>>;
+
+export type GetInferenceHelpers<
+  TType extends 'input' | 'output',
+  TRoot extends AnyTRPCClientTypes,
+  TRecord extends TRPCRouterRecord
+> = {
+  [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value
+    ? $Value extends TRPCRouterRecord
+      ? GetInferenceHelpers<TType, TRoot, $Value>
+      : $Value extends AnyProcedure
+      ? inferProcedureOutput<$Value> // inferTransformedProcedureOutput<TRoot, $Value>
+      : never
+    : never;
+};
+
+export type inferRouterOutputs<TRouter extends AnyRouter> = GetInferenceHelpers<
+  'output',
+  TRouter['_def']['_config']['$types'],
+  TRouter['_def']['record']
+>;
+
+// type SpecificOutput = Router['_def']['record']['createInterfaceDraft']['_def']['$types']['output'];
+// type TestOutput = RouterOutput['createInterfaceDraft'];

package/skill/index.ts

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

package/skill/skill.models.ts

@@ -0,0 +1,16 @@
+import * as mongo from '@arken/node/mongo';
+import type * as Types from './skill.types';
+
+export const Skill = mongo.createModel<Types.SkillDocument>('Skill', {});
+
+export const SkillMod = mongo.createModel<Types.SkillModDocument>('SkillMod', {});
+
+export const SkillClassification = mongo.createModel<Types.SkillClassificationDocument>('SkillClassification', {});
+
+export const SkillCondition = mongo.createModel<Types.SkillConditionDocument>('SkillCondition', {});
+
+export const SkillStatusEffect = mongo.createModel<Types.SkillStatusEffectDocument>('SkillStatusEffect', {});
+
+export const SkillTree = mongo.createModel<Types.SkillTreeDocument>('SkillTree', {});
+
+export const SkillTreeNode = mongo.createModel<Types.SkillTreeNodeDocument>('SkillTreeNode', {});

package/skill/skill.router.ts

@@ -0,0 +1,201 @@
+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 {
+  Skill,
+  SkillMod,
+  SkillClassification,
+  SkillCondition,
+  SkillStatusEffect,
+  SkillTree,
+  SkillTreeNode,
+} from './skill.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({
+    // Skill Procedures
+    getSkill: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkill as any)(input, ctx)),
+
+    createSkill: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: Skill.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkill as any)(input, ctx)),
+
+    updateSkill: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: Skill.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkill as any)(input, ctx)),
+
+    deleteSkill: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkill as any)(input, ctx)),
+
+    // SkillMod Procedures
+    getSkillMod: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillMod as any)(input, ctx)),
+
+    createSkillMod: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillMod.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillMod as any)(input, ctx)),
+
+    updateSkillMod: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillMod.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillMod as any)(input, ctx)),
+
+    deleteSkillMod: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillMod as any)(input, ctx)),
+
+    // SkillClassification Procedures
+    getSkillClassification: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillClassification as any)(input, ctx)),
+
+    createSkillClassification: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillClassification.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillClassification as any)(input, ctx)),
+
+    updateSkillClassification: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillClassification.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillClassification as any)(input, ctx)),
+
+    deleteSkillClassification: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillClassification as any)(input, ctx)),
+
+    // SkillCondition Procedures
+    getSkillCondition: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillCondition as any)(input, ctx)),
+
+    createSkillCondition: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillCondition.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillCondition as any)(input, ctx)),
+
+    updateSkillCondition: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillCondition.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillCondition as any)(input, ctx)),
+
+    deleteSkillCondition: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillCondition as any)(input, ctx)),
+
+    // SkillStatusEffect Procedures
+    getSkillStatusEffect: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillStatusEffect as any)(input, ctx)),
+
+    createSkillStatusEffect: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillStatusEffect.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillStatusEffect as any)(input, ctx)),
+
+    updateSkillStatusEffect: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillStatusEffect.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillStatusEffect as any)(input, ctx)),
+
+    deleteSkillStatusEffect: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillStatusEffect as any)(input, ctx)),
+
+    // SkillTree Procedures
+    getSkillTree: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillTree as any)(input, ctx)),
+
+    createSkillTree: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillTree.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillTree as any)(input, ctx)),
+
+    updateSkillTree: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillTree.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillTree as any)(input, ctx)),
+
+    deleteSkillTree: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillTree as any)(input, ctx)),
+
+    // SkillTreeNode Procedures
+    getSkillTreeNode: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillTreeNode as any)(input, ctx)),
+
+    createSkillTreeNode: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: SkillTreeNode.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillTreeNode as any)(input, ctx)),
+
+    updateSkillTreeNode: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: SkillTreeNode.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillTreeNode as any)(input, ctx)),
+
+    deleteSkillTreeNode: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillTreeNode as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/skill/skill.schema.ts

@@ -0,0 +1,52 @@
+import { z, ObjectId, Entity } from '../schema';
+
+export const Skill = Entity.merge(
+  z.object({
+    name: z.string().min(1),
+    description: z
+      .string()
+      .min(1)
+      .optional(),
+    type: z.enum(['attack', 'defense', 'utility']),
+    cooldown: z
+      .number()
+      .min(0)
+      .optional(),
+    power: z
+      .number()
+      .min(0)
+      .optional(),
+  })
+);
+
+export const SkillEffect = Entity.merge(
+  z.object({
+    skillId: ObjectId, // Reference to the associated Skill
+    effectType: z.enum(['damage', 'heal', 'buff', 'debuff']),
+    magnitude: z.number().min(0),
+    duration: z
+      .number()
+      .min(0)
+      .optional(),
+  })
+);
+
+export const SkillRequirement = Entity.merge(
+  z.object({
+    skillId: ObjectId, // Reference to the associated Skill
+    levelRequired: z.number().min(1),
+    previousSkillId: ObjectId.optional(), // Reference to a prerequisite skill
+  })
+);
+
+export const SkillMod = Entity.merge(z.object({}));
+
+export const SkillClassification = Entity.merge(z.object({}));
+
+export const SkillCondition = Entity.merge(z.object({}));
+
+export const SkillStatusEffect = Entity.merge(z.object({}));
+
+export const SkillTree = Entity.merge(z.object({}));
+
+export const SkillTreeNode = Entity.merge(z.object({}));

package/skill/skill.types.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import * as schema from './skill.schema';
+import { Document, Model } from '@arken/node/mongo';
+
+export type * from './skill.router';
+export type { RouterContext } from '../types';
+
+export type Skill = z.infer<typeof schema.Skill>;
+export type SkillMod = z.infer<typeof schema.SkillMod>;
+export type SkillClassification = z.infer<typeof schema.SkillClassification>;
+export type SkillCondition = z.infer<typeof schema.SkillCondition>;
+export type SkillStatusEffect = z.infer<typeof schema.SkillStatusEffect>;
+export type SkillTree = z.infer<typeof schema.SkillTree>;
+export type SkillTreeNode = z.infer<typeof schema.SkillTreeNode>;
+
+export type SkillDocument = Skill & Document;
+export type SkillModDocument = SkillMod & Document;
+export type SkillClassificationDocument = SkillClassification & Document;
+export type SkillConditionDocument = SkillCondition & Document;
+export type SkillStatusEffectDocument = SkillStatusEffect & Document;
+export type SkillTreeDocument = SkillTree & Document;
+export type SkillTreeNodeDocument = SkillTreeNode & Document;
+
+export type Mappings = {
+  Skill: Model<SkillDocument>;
+  SkillMod: Model<SkillModDocument>;
+  SkillClassification: Model<SkillClassificationDocument>;
+  SkillCondition: Model<SkillConditionDocument>;
+  SkillStatusEffect: Model<SkillStatusEffectDocument>;
+  SkillTree: Model<SkillTreeDocument>;
+  SkillTreeNode: Model<SkillTreeNodeDocument>;
+};

package/trek/index.ts

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

package/trek/trek.models.ts

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

package/trek/trek.router.ts

@@ -2,9 +2,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 type { inferRouterOutputs, inferRouterInputs } from '@trpc/server';
-import type { RouterContext } from '../../types';
+import type { RouterContext } from '../types';
 
 export const z = zod;
 export const t = initTRPC.context<RouterContext>().create();

package/trek/trek.schema.ts

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

package/trek/trek.types.ts

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