@nmtjs/contract 0.0.4 → 0.1.1

package/dist/index.js

@@ -0,0 +1,16 @@
+import { t as baseT } from '@nmtjs/type';
+import { EventContract } from "./schemas/event.js";
+import { ProcedureContract } from "./schemas/procedure.js";
+import { ServiceContract } from "./schemas/service.js";
+import { SubscriptionContract } from "./schemas/subscription.js";
+import { blob } from "./types/blob.js";
+export var c;
+(function(c) {
+    c.procedure = ProcedureContract;
+    c.event = EventContract;
+    c.subscription = SubscriptionContract;
+    c.service = ServiceContract;
+})(c || (c = {}));
+export const t = Object.assign({}, baseT, {
+    blob
+});

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import { t as baseT } from '@nmtjs/type'\nimport { EventContract, type TEventContract } from './schemas/event.ts'\n\nimport {\n  ProcedureContract,\n  type TBaseProcedureContract,\n  type TProcedureContract,\n} from './schemas/procedure.ts'\nimport { ServiceContract, type TServiceContract } from './schemas/service.ts'\nimport {\n  SubscriptionContract,\n  type TSubscriptionContract,\n} from './schemas/subscription.ts'\nimport { blob } from './types/blob.ts'\n\nexport type {\n  TEventContract,\n  TProcedureContract,\n  TBaseProcedureContract,\n  TServiceContract,\n  TSubscriptionContract,\n}\n\nexport namespace c {\n  export const procedure = ProcedureContract\n  export const event = EventContract\n  export const subscription = SubscriptionContract\n  export const service = ServiceContract\n}\n\nexport const t = Object.assign({}, baseT, { blob })\n"],"names":["t","baseT","EventContract","ProcedureContract","ServiceContract","SubscriptionContract","blob","c","procedure","event","subscription","service","Object","assign"],"mappings":"AAAA,SAASA,KAAKC,KAAK,QAAQ,cAAa;AACxC,SAASC,aAAa,QAA6B,qBAAoB;AAEvE,SACEC,iBAAiB,QAGZ,yBAAwB;AAC/B,SAASC,eAAe,QAA+B,uBAAsB;AAC7E,SACEC,oBAAoB,QAEf,4BAA2B;AAClC,SAASC,IAAI,QAAQ,kBAAiB;;UAUrBC;MACFC,YAAYL;MACZM,QAAQP;MACRQ,eAAeL;MACfM,UAAUP;AACzB,GALiBG,MAAAA;AAOjB,OAAO,MAAMP,IAAIY,OAAOC,MAAM,CAAC,CAAC,GAAGZ,OAAO;IAAEK;AAAK,GAAE"}

package/dist/schemas/event.js

@@ -1,12 +1,12 @@
-import { Kind, TypeRegistry } from '@sinclair/typebox/type';
 import { createSchema } from "../utils.js";
 export const EventKind = 'NeemataEvent';
 export const EventContract = (payload, schemaOptions = {})=>{
-    if (!TypeRegistry.Has(EventKind)) TypeRegistry.Set(EventKind, ()=>true);
     return createSchema({
         ...schemaOptions,
-        [Kind]: EventKind,
         type: 'neemata:event',
-        payload
+        payload,
+        name: undefined,
+        serviceName: undefined,
+        subscriptionName: undefined
     });
 };

package/dist/schemas/event.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/schemas/event.ts"],"sourcesContent":["import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport const EventKind = 'NeemataEvent'\n\nexport interface TEventContract<\n  Payload extends TSchema = any,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  SubscriptionName extends string | undefined = string | undefined,\n> extends TSchema {\n  [Kind]: typeof EventKind\n  type: 'neemata:event'\n  static: {\n    payload: Payload['static']\n  }\n  name: Name\n  serviceName: ServiceName\n  subscriptionName: SubscriptionName\n  payload: Payload\n}\n\nexport const EventContract = <Payload extends TSchema>(\n  payload: Payload,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  if (!TypeRegistry.Has(EventKind)) TypeRegistry.Set(EventKind, () => true)\n\n  return createSchema<TEventContract<Payload>>({\n    ...schemaOptions,\n    [Kind]: EventKind,\n    type: 'neemata:event',\n    payload,\n  })\n}\n"],"names":["Kind","TypeRegistry","createSchema","EventKind","EventContract","payload","schemaOptions","Has","Set","type"],"mappings":"AAAA,SAASA,IAAI,EAAgBC,YAAY,QAAQ,yBAAwB;AACzE,SAAqCC,YAAY,QAAQ,cAAa;AAEtE,OAAO,MAAMC,YAAY,eAAc;AAmBvC,OAAO,MAAMC,gBAAgB,CAC3BC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,IAAI,CAACL,aAAaM,GAAG,CAACJ,YAAYF,aAAaO,GAAG,CAACL,WAAW,IAAM;IAEpE,OAAOD,aAAsC;QAC3C,GAAGI,aAAa;QAChB,CAACN,KAAK,EAAEG;QACRM,MAAM;QACNJ;IACF;AACF,EAAC"}
+{"version":3,"sources":["../../../src/schemas/event.ts"],"sourcesContent":["import { type BaseType, type TSchema, getTypeSchema } from '@nmtjs/type'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport const EventKind = 'NeemataEvent'\n\nexport interface TEventContract<\n  Payload extends BaseType = BaseType,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  SubscriptionName extends string | undefined = string | undefined,\n> {\n  type: 'neemata:event'\n  name: Name\n  serviceName: ServiceName\n  subscriptionName: SubscriptionName\n  payload: Payload\n}\n\nexport const EventContract = <Payload extends BaseType>(\n  payload: Payload,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  return createSchema<TEventContract<Payload>>({\n    ...schemaOptions,\n    type: 'neemata:event',\n    payload,\n    name: undefined,\n    serviceName: undefined,\n    subscriptionName: undefined,\n  })\n}\n"],"names":["createSchema","EventKind","EventContract","payload","schemaOptions","type","name","undefined","serviceName","subscriptionName"],"mappings":"AACA,SAAqCA,YAAY,QAAQ,cAAa;AAEtE,OAAO,MAAMC,YAAY,eAAc;AAevC,OAAO,MAAMC,gBAAgB,CAC3BC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,OAAOJ,aAAsC;QAC3C,GAAGI,aAAa;QAChBC,MAAM;QACNF;QACAG,MAAMC;QACNC,aAAaD;QACbE,kBAAkBF;IACpB;AACF,EAAC"}

package/dist/schemas/procedure.js

@@ -1,14 +1,13 @@
-import { Kind, TypeRegistry } from '@sinclair/typebox/type';
 import { createSchema } from "../utils.js";
-export const ProcedureKind = 'NeemataProcedure';
 export const ProcedureContract = (input, output, timeout, schemaOptions = {})=>{
-    if (!TypeRegistry.Has(ProcedureKind)) TypeRegistry.Set(ProcedureKind, ()=>true);
     return createSchema({
         ...schemaOptions,
-        [Kind]: ProcedureKind,
         type: 'neemata:procedure',
         input,
         output,
-        timeout
+        timeout,
+        name: undefined,
+        serviceName: undefined,
+        transports: undefined
     });
 };

package/dist/schemas/procedure.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/schemas/procedure.ts"],"sourcesContent":["import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'\n\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport const ProcedureKind = 'NeemataProcedure'\n\nexport interface TBaseProcedureContract<\n  Input extends TSchema = TSchema,\n  Output extends TSchema = TSchema,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n> extends TSchema {\n  name: Name\n  serviceName: ServiceName\n  transports: Transports\n  input: Input\n  output: Output\n  timeout?: number\n}\n\nexport interface TProcedureContract<\n  Input extends TSchema = TSchema,\n  Output extends TSchema = TSchema,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n> extends TBaseProcedureContract<Input, Output, Name, ServiceName, Transports> {\n  [Kind]: typeof ProcedureKind\n  type: 'neemata:procedure'\n  static: {\n    input: Input['static']\n    output: Output['static']\n  }\n}\n\nexport const ProcedureContract = <\n  Input extends TSchema,\n  Output extends TSchema,\n>(\n  input: Input,\n  output: Output,\n  timeout?: number,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  if (!TypeRegistry.Has(ProcedureKind))\n    TypeRegistry.Set(ProcedureKind, () => true)\n\n  return createSchema<TProcedureContract<Input, Output>>({\n    ...schemaOptions,\n    [Kind]: ProcedureKind,\n    type: 'neemata:procedure',\n    input,\n    output,\n    timeout,\n  })\n}\n"],"names":["Kind","TypeRegistry","createSchema","ProcedureKind","ProcedureContract","input","output","timeout","schemaOptions","Has","Set","type"],"mappings":"AAAA,SAASA,IAAI,EAAgBC,YAAY,QAAQ,yBAAwB;AAEzE,SAAqCC,YAAY,QAAQ,cAAa;AAEtE,OAAO,MAAMC,gBAAgB,mBAAkB;AAoC/C,OAAO,MAAMC,oBAAoB,CAI/BC,OACAC,QACAC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,IAAI,CAACP,aAAaQ,GAAG,CAACN,gBACpBF,aAAaS,GAAG,CAACP,eAAe,IAAM;IAExC,OAAOD,aAAgD;QACrD,GAAGM,aAAa;QAChB,CAACR,KAAK,EAAEG;QACRQ,MAAM;QACNN;QACAC;QACAC;IACF;AACF,EAAC"}
+{"version":3,"sources":["../../../src/schemas/procedure.ts"],"sourcesContent":["import type { BaseType } from '@nmtjs/type'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport interface TBaseProcedureContract<\n  Type extends string = string,\n  Input extends BaseType = BaseType,\n  Output extends BaseType = BaseType,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n> {\n  type: Type\n  name: Name\n  serviceName: ServiceName\n  transports: Transports\n  input: Input\n  output: Output\n  timeout?: number\n}\n\nexport interface TProcedureContract<\n  Input extends BaseType = BaseType,\n  Output extends BaseType = BaseType,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n> extends TBaseProcedureContract<\n    'neemata:procedure',\n    Input,\n    Output,\n    Name,\n    ServiceName,\n    Transports\n  > {}\n\nexport const ProcedureContract = <\n  Input extends BaseType,\n  Output extends BaseType,\n>(\n  input: Input,\n  output: Output,\n  timeout?: number,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  return createSchema<TProcedureContract<Input, Output>>({\n    ...schemaOptions,\n    type: 'neemata:procedure',\n    input,\n    output,\n    timeout,\n    name: undefined,\n    serviceName: undefined,\n    transports: undefined,\n  })\n}\n"],"names":["createSchema","ProcedureContract","input","output","timeout","schemaOptions","type","name","undefined","serviceName","transports"],"mappings":"AACA,SAAqCA,YAAY,QAAQ,cAAa;AAsCtE,OAAO,MAAMC,oBAAoB,CAI/BC,OACAC,QACAC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,OAAOL,aAAgD;QACrD,GAAGK,aAAa;QAChBC,MAAM;QACNJ;QACAC;QACAC;QACAG,MAAMC;QACNC,aAAaD;QACbE,YAAYF;IACd;AACF,EAAC"}

package/dist/schemas/service.js

@@ -1,12 +1,8 @@
-import { Kind, TypeRegistry } from '@sinclair/typebox/type';
 import { applyNames, createSchema } from "../utils.js";
-import { SubscriptionKind } from "./subscription.js";
-export const ServiceKind = 'NeemataService';
 export const ServiceContract = (name, transports, procedures = {}, events = {}, timeout, schemaOptions = {})=>{
-    if (!TypeRegistry.Has(ServiceKind)) TypeRegistry.Set(ServiceKind, ()=>true);
     const serviceProcedures = {};
     for (const [procedureName, procedure] of Object.entries(procedures)){
-        if (procedure[Kind] === SubscriptionKind) {
+        if (procedure.type === 'neemata:subscription') {
             serviceProcedures[procedureName] = {
                 ...procedure,
                 events: applyNames(procedure.events, {
@@ -20,7 +16,6 @@ export const ServiceContract = (name, transports, procedures = {}, events = {},
     }
     return createSchema({
         ...schemaOptions,
-        [Kind]: ServiceKind,
         name: name,
         type: 'neemata:service',
         procedures: applyNames(procedures, {

package/dist/schemas/service.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/schemas/service.ts"],"sourcesContent":["import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'\nimport {\n  type ContractSchemaOptions,\n  applyNames,\n  createSchema,\n} from '../utils.ts'\nimport type { TEventContract } from './event.ts'\nimport type { TProcedureContract } from './procedure.ts'\nimport { SubscriptionKind, type TSubscriptionContract } from './subscription.ts'\n\nexport const ServiceKind = 'NeemataService'\n\nexport interface TServiceContract<\n  Name extends string = string,\n  Transports extends { [K in string]?: true } = { [K in string]?: true },\n  Procedures extends Record<\n    string,\n    TProcedureContract | TSubscriptionContract\n  > = Record<string, TProcedureContract | TSubscriptionContract>,\n  Events extends Record<string, TEventContract> = Record<\n    string,\n    TEventContract\n  >,\n> extends TSchema {\n  [Kind]: typeof ServiceKind\n  static: {\n    procedures: {\n      [K in keyof Procedures]: Procedures[K]['static']\n    }\n    subscriptions: {\n      [K in keyof Procedures]: Procedures[K]['static']\n    }\n    events: {\n      [K in keyof Events]: Events[K]['static']\n    }\n    transports: Transports\n  }\n  type: 'neemata:service'\n  name: Name\n  transports: Transports\n  procedures: {\n    [K in keyof Procedures]: Procedures[K] extends TProcedureContract<\n      infer Input,\n      infer Output\n    >\n      ? TProcedureContract<Input, Output, Extract<K, string>, Name, Transports>\n      : Procedures[K] extends TSubscriptionContract<\n            infer Input,\n            infer Output,\n            infer Options,\n            infer Events\n          >\n        ? TSubscriptionContract<\n            Input,\n            Output,\n            Options,\n            {\n              [EK in keyof Events]: Events[EK] extends TEventContract<\n                infer Payload\n              >\n                ? TEventContract<\n                    Payload,\n                    Extract<EK, string>,\n                    Name,\n                    Extract<K, string>\n                  >\n                : never\n            },\n            Extract<K, string>,\n            Name,\n            Transports\n          >\n        : never\n  }\n  events: {\n    [K in Extract<keyof Events, string>]: Events[K] extends TEventContract<\n      infer Payload\n    >\n      ? TEventContract<Payload, K, Name>\n      : never\n  }\n  timeout?: number\n}\n\nexport const ServiceContract = <\n  Name extends string,\n  Transports extends { [key: string]: true },\n  Procedures extends Record<string, TProcedureContract | TSubscriptionContract>,\n  Events extends Record<string, TEventContract>,\n>(\n  name: Name,\n  transports: Transports,\n  procedures: Procedures = {} as Procedures,\n  events: Events = {} as Events,\n  timeout?: number,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  if (!TypeRegistry.Has(ServiceKind)) TypeRegistry.Set(ServiceKind, () => true)\n\n  const serviceProcedures = {}\n\n  for (const [procedureName, procedure] of Object.entries(procedures)) {\n    if (procedure[Kind] === SubscriptionKind) {\n      serviceProcedures[procedureName] = {\n        ...procedure,\n        events: applyNames(procedure.events, {\n          serviceName: name,\n          subscriptionName: procedureName,\n        }),\n      }\n    } else {\n      serviceProcedures[procedureName] = procedure\n    }\n  }\n\n  return createSchema<TServiceContract<Name, Transports, Procedures, Events>>({\n    ...schemaOptions,\n    [Kind]: ServiceKind,\n    name: name,\n    type: 'neemata:service',\n    procedures: applyNames(procedures, { serviceName: name }),\n    events: applyNames(events, { serviceName: name }),\n    transports,\n    timeout,\n  })\n}\n"],"names":["Kind","TypeRegistry","applyNames","createSchema","SubscriptionKind","ServiceKind","ServiceContract","name","transports","procedures","events","timeout","schemaOptions","Has","Set","serviceProcedures","procedureName","procedure","Object","entries","serviceName","subscriptionName","type"],"mappings":"AAAA,SAASA,IAAI,EAAgBC,YAAY,QAAQ,yBAAwB;AACzE,SAEEC,UAAU,EACVC,YAAY,QACP,cAAa;AAGpB,SAASC,gBAAgB,QAAoC,oBAAmB;AAEhF,OAAO,MAAMC,cAAc,iBAAgB;AA0E3C,OAAO,MAAMC,kBAAkB,CAM7BC,MACAC,YACAC,aAAyB,CAAC,CAAe,EACzCC,SAAiB,CAAC,CAAW,EAC7BC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,IAAI,CAACX,aAAaY,GAAG,CAACR,cAAcJ,aAAaa,GAAG,CAACT,aAAa,IAAM;IAExE,MAAMU,oBAAoB,CAAC;IAE3B,KAAK,MAAM,CAACC,eAAeC,UAAU,IAAIC,OAAOC,OAAO,CAACV,YAAa;QACnE,IAAIQ,SAAS,CAACjB,KAAK,KAAKI,kBAAkB;YACxCW,iBAAiB,CAACC,cAAc,GAAG;gBACjC,GAAGC,SAAS;gBACZP,QAAQR,WAAWe,UAAUP,MAAM,EAAE;oBACnCU,aAAab;oBACbc,kBAAkBL;gBACpB;YACF;QACF,OAAO;YACLD,iBAAiB,CAACC,cAAc,GAAGC;QACrC;IACF;IAEA,OAAOd,aAAqE;QAC1E,GAAGS,aAAa;QAChB,CAACZ,KAAK,EAAEK;QACRE,MAAMA;QACNe,MAAM;QACNb,YAAYP,WAAWO,YAAY;YAAEW,aAAab;QAAK;QACvDG,QAAQR,WAAWQ,QAAQ;YAAEU,aAAab;QAAK;QAC/CC;QACAG;IACF;AACF,EAAC"}
+{"version":3,"sources":["../../../src/schemas/service.ts"],"sourcesContent":["import {\n  type ContractSchemaOptions,\n  applyNames,\n  createSchema,\n} from '../utils.ts'\nimport type { TEventContract } from './event.ts'\nimport type { TBaseProcedureContract, TProcedureContract } from './procedure.ts'\nimport type { TSubscriptionContract } from './subscription.ts'\n\nexport interface TServiceContract<\n  Name extends string = string,\n  Transports extends { [K in string]?: true } = { [K in string]?: true },\n  Procedures extends Record<string, TBaseProcedureContract> = Record<\n    string,\n    TProcedureContract | TSubscriptionContract\n  >,\n  Events extends Record<string, TEventContract> = Record<\n    string,\n    TEventContract\n  >,\n> {\n  type: 'neemata:service'\n  name: Name\n  transports: Transports\n  procedures: {\n    [K in keyof Procedures]: Procedures[K] extends TProcedureContract<\n      infer Input,\n      infer Output,\n      any,\n      any,\n      any\n    >\n      ? // ? true\n        TProcedureContract<Input, Output, Extract<K, string>, Name, Transports>\n      : Procedures[K] extends TSubscriptionContract<\n            infer Input,\n            infer Output,\n            infer Options,\n            infer Events,\n            any,\n            any,\n            any\n          >\n        ? TSubscriptionContract<\n            Input,\n            Output,\n            Options,\n            {\n              [EK in keyof Events]: Events[EK] extends TEventContract<\n                infer Payload\n              >\n                ? TEventContract<\n                    Payload,\n                    Extract<EK, string>,\n                    Name,\n                    Extract<K, string>\n                  >\n                : never\n            },\n            Extract<K, string>,\n            Name,\n            Transports\n          >\n        : Procedures[K]\n  }\n  events: {\n    [K in Extract<keyof Events, string>]: Events[K] extends TEventContract<\n      infer Payload\n    >\n      ? TEventContract<Payload, K, Name>\n      : Events[K]\n  }\n  timeout?: number\n}\n\nexport const ServiceContract = <\n  Name extends string,\n  Transports extends { [key: string]: true },\n  Procedures extends Record<string, TProcedureContract | TSubscriptionContract>,\n  Events extends Record<string, TEventContract>,\n>(\n  name: Name,\n  transports: Transports,\n  procedures: Procedures = {} as Procedures,\n  events: Events = {} as Events,\n  timeout?: number,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  const serviceProcedures = {}\n\n  for (const [procedureName, procedure] of Object.entries(procedures)) {\n    if (procedure.type === 'neemata:subscription') {\n      serviceProcedures[procedureName] = {\n        ...procedure,\n        events: applyNames(procedure.events, {\n          serviceName: name,\n          subscriptionName: procedureName,\n        }),\n      }\n    } else {\n      serviceProcedures[procedureName] = procedure\n    }\n  }\n\n  return createSchema<TServiceContract<Name, Transports, Procedures, Events>>({\n    ...schemaOptions,\n    name: name,\n    type: 'neemata:service',\n    // @ts-expect-error\n    procedures: applyNames(procedures, { serviceName: name }),\n    // @ts-expect-error\n    events: applyNames(events, { serviceName: name }),\n    transports,\n    timeout,\n  })\n}\n\ntype A<T extends boolean> = {\n  // type: 'boolean'\n  a: T\n}\ntype B<T extends number> = {\n  // type: 'number'\n  b: T\n}\ntype T = Record<string, A<boolean> | B<number>>\n\ntype TT<TTT extends T> = {\n  [K in keyof TTT]: TTT[K] extends A<infer T>\n    ? T\n    : TTT[K] extends B<infer T>\n      ? T\n      : never\n}\n\ntype TTT = TT<{ r: A<false> }>\n"],"names":["applyNames","createSchema","ServiceContract","name","transports","procedures","events","timeout","schemaOptions","serviceProcedures","procedureName","procedure","Object","entries","type","serviceName","subscriptionName"],"mappings":"AAAA,SAEEA,UAAU,EACVC,YAAY,QACP,cAAa;AAuEpB,OAAO,MAAMC,kBAAkB,CAM7BC,MACAC,YACAC,aAAyB,CAAC,CAAe,EACzCC,SAAiB,CAAC,CAAW,EAC7BC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,MAAMC,oBAAoB,CAAC;IAE3B,KAAK,MAAM,CAACC,eAAeC,UAAU,IAAIC,OAAOC,OAAO,CAACR,YAAa;QACnE,IAAIM,UAAUG,IAAI,KAAK,wBAAwB;YAC7CL,iBAAiB,CAACC,cAAc,GAAG;gBACjC,GAAGC,SAAS;gBACZL,QAAQN,WAAWW,UAAUL,MAAM,EAAE;oBACnCS,aAAaZ;oBACba,kBAAkBN;gBACpB;YACF;QACF,OAAO;YACLD,iBAAiB,CAACC,cAAc,GAAGC;QACrC;IACF;IAEA,OAAOV,aAAqE;QAC1E,GAAGO,aAAa;QAChBL,MAAMA;QACNW,MAAM;QAENT,YAAYL,WAAWK,YAAY;YAAEU,aAAaZ;QAAK;QAEvDG,QAAQN,WAAWM,QAAQ;YAAES,aAAaZ;QAAK;QAC/CC;QACAG;IACF;AACF,EAAC"}

package/dist/schemas/subscription.js

@@ -1,16 +1,15 @@
-import { Kind, TypeRegistry } from '@sinclair/typebox/type';
 import { createSchema } from "../utils.js";
-export const SubscriptionKind = 'NeemataSubscription';
-export const SubscriptionContract = (input, output, options, events, timeout, schemaOptions = {})=>{
-    if (!TypeRegistry.Has(SubscriptionKind)) TypeRegistry.Set(SubscriptionKind, ()=>true);
-    return createSchema({
-        ...schemaOptions,
-        [Kind]: SubscriptionKind,
-        type: 'neemata:subscription',
-        input,
-        output,
-        events,
-        options,
-        timeout
-    });
+export const SubscriptionContract = (input, output, events, timeout, schemaOptions = {})=>{
+    return ()=>createSchema({
+            ...schemaOptions,
+            type: 'neemata:subscription',
+            input,
+            output,
+            events,
+            timeout,
+            options: undefined,
+            name: undefined,
+            serviceName: undefined,
+            transports: undefined
+        });
 };

package/dist/schemas/subscription.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/schemas/subscription.ts"],"sourcesContent":["import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TEventContract } from './event.ts'\nimport type { TBaseProcedureContract } from './procedure.ts'\n\nexport const SubscriptionKind = 'NeemataSubscription'\n\nexport type TSubcriptionOptions = { static: Record<string, string | number> }\n\nexport interface TSubscriptionContract<\n  Input extends TSchema = TSchema,\n  Output extends TSchema = TSchema,\n  Options extends TSubcriptionOptions = TSubcriptionOptions,\n  Events extends Record<string, TEventContract> = Record<\n    string,\n    TEventContract\n  >,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n> extends TBaseProcedureContract<Input, Output, Name, ServiceName, Transports> {\n  [Kind]: typeof SubscriptionKind\n  type: 'neemata:subscription'\n  static: {\n    input: Input['static']\n    output: Output['static']\n    options: Options['static']\n    events: {\n      [K in keyof Events]: Events[K]['static']\n    }\n  }\n  options: Options\n  events: Events\n}\n\nexport const SubscriptionContract = <\n  Input extends TSchema = TSchema,\n  Output extends TSchema = TSchema,\n  Options extends TSubcriptionOptions = TSubcriptionOptions,\n  Events extends Record<string, TEventContract> = Record<\n    string,\n    TEventContract\n  >,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n>(\n  input: Input,\n  output: Output,\n  options: Options,\n  events: Events,\n  timeout?: number,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  if (!TypeRegistry.Has(SubscriptionKind))\n    TypeRegistry.Set(SubscriptionKind, () => true)\n\n  return createSchema<\n    TSubscriptionContract<\n      Input,\n      Output,\n      Options,\n      Events,\n      Name,\n      ServiceName,\n      Transports\n    >\n  >({\n    ...schemaOptions,\n    [Kind]: SubscriptionKind,\n    type: 'neemata:subscription',\n    input,\n    output,\n    events,\n    options,\n    timeout,\n  })\n}\n"],"names":["Kind","TypeRegistry","createSchema","SubscriptionKind","SubscriptionContract","input","output","options","events","timeout","schemaOptions","Has","Set","type"],"mappings":"AAAA,SAASA,IAAI,EAAgBC,YAAY,QAAQ,yBAAwB;AACzE,SAAqCC,YAAY,QAAQ,cAAa;AAItE,OAAO,MAAMC,mBAAmB,sBAAqB;AAgCrD,OAAO,MAAMC,uBAAuB,CAclCC,OACAC,QACAC,SACAC,QACAC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,IAAI,CAACT,aAAaU,GAAG,CAACR,mBACpBF,aAAaW,GAAG,CAACT,kBAAkB,IAAM;IAE3C,OAAOD,aAUL;QACA,GAAGQ,aAAa;QAChB,CAACV,KAAK,EAAEG;QACRU,MAAM;QACNR;QACAC;QACAE;QACAD;QACAE;IACF;AACF,EAAC"}
+{"version":3,"sources":["../../../src/schemas/subscription.ts"],"sourcesContent":["import type { BaseType } from '@nmtjs/type'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TEventContract } from './event.ts'\nimport type { TBaseProcedureContract } from './procedure.ts'\n\nexport type TSubcriptionOptions = Record<string, string | number>\n\nexport interface TSubscriptionContract<\n  Input extends BaseType = BaseType,\n  Output extends BaseType = BaseType,\n  Options extends TSubcriptionOptions = TSubcriptionOptions,\n  Events extends Record<string, TEventContract> = Record<\n    string,\n    TEventContract\n  >,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n> extends TBaseProcedureContract<\n    'neemata:subscription',\n    Input,\n    Output,\n    Name,\n    ServiceName,\n    Transports\n  > {\n  options: Options\n  events: Events\n}\n\nexport const SubscriptionContract = <\n  Input extends BaseType = BaseType,\n  Output extends BaseType = BaseType,\n  Events extends Record<string, TEventContract> = Record<\n    string,\n    TEventContract\n  >,\n>(\n  input: Input,\n  output: Output,\n  events: Events,\n  timeout?: number,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  return <Options extends TSubcriptionOptions>() =>\n    createSchema<TSubscriptionContract<Input, Output, Options, Events>>({\n      ...schemaOptions,\n      type: 'neemata:subscription',\n      input,\n      output,\n      events,\n      timeout,\n      options: undefined as unknown as Options,\n      name: undefined,\n      serviceName: undefined,\n      transports: undefined,\n    })\n}\n"],"names":["createSchema","SubscriptionContract","input","output","events","timeout","schemaOptions","type","options","undefined","name","serviceName","transports"],"mappings":"AACA,SAAqCA,YAAY,QAAQ,cAAa;AA+BtE,OAAO,MAAMC,uBAAuB,CAQlCC,OACAC,QACAC,QACAC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,OAAO,IACLN,aAAoE;YAClE,GAAGM,aAAa;YAChBC,MAAM;YACNL;YACAC;YACAC;YACAC;YACAG,SAASC;YACTC,MAAMD;YACNE,aAAaF;YACbG,YAAYH;QACd;AACJ,EAAC"}

package/dist/types/blob.js

@@ -0,0 +1,13 @@
+import { t } from '@nmtjs/type';
+export const BlobKind = 'ApiBlob';
+export const blob = (options = {})=>t.custom((value)=>{
+        if ('metadata' in value) {
+            if (options.maxSize) {
+                const size = value.metadata.size;
+                if (size === -1 || size > options.maxSize) {
+                    throw new Error('Blob size unknown or exceeds maximum allowed size');
+                }
+            }
+        }
+        return value;
+    }, (value)=>value);

package/dist/types/blob.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/types/blob.ts"],"sourcesContent":["import type { ApiBlobInterface } from '@nmtjs/common'\nimport { t } from '@nmtjs/type'\n\nexport const BlobKind = 'ApiBlob'\n\nexport interface BlobOptions {\n  maxSize?: number\n  contentType?: string\n}\n\nexport const blob = (options: BlobOptions = {}) =>\n  t.custom<ApiBlobInterface>(\n    (value) => {\n      if ('metadata' in value) {\n        if (options.maxSize) {\n          const size = (value as ApiBlobInterface).metadata.size\n          if (size === -1 || size > options.maxSize) {\n            throw new Error('Blob size unknown or exceeds maximum allowed size')\n          }\n        }\n      }\n      return value\n    },\n    (value) => value,\n  )\n"],"names":["t","BlobKind","blob","options","custom","value","maxSize","size","metadata","Error"],"mappings":"AACA,SAASA,CAAC,QAAQ,cAAa;AAE/B,OAAO,MAAMC,WAAW,UAAS;AAOjC,OAAO,MAAMC,OAAO,CAACC,UAAuB,CAAC,CAAC,GAC5CH,EAAEI,MAAM,CACN,CAACC;QACC,IAAI,cAAcA,OAAO;YACvB,IAAIF,QAAQG,OAAO,EAAE;gBACnB,MAAMC,OAAO,AAACF,MAA2BG,QAAQ,CAACD,IAAI;gBACtD,IAAIA,SAAS,CAAC,KAAKA,OAAOJ,QAAQG,OAAO,EAAE;oBACzC,MAAM,IAAIG,MAAM;gBAClB;YACF;QACF;QACA,OAAOJ;IACT,GACA,CAACA,QAAUA,OACZ"}

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["import type { SchemaOptions, TSchema } from '@sinclair/typebox'\n\nexport type ContractSchemaOptions = Pick<SchemaOptions, 'title' | 'description'>\n\nexport const applyNames = <T extends Record<string, { serviceName?: string }>>(\n  params: T,\n  opts: { serviceName?: string; subscriptionName?: string },\n) => {\n  return Object.fromEntries(\n    Object.entries(params).map(([k, v]) => [k, { ...v, name: k, ...opts }]),\n  )\n}\n\nexport const createSchema = <T extends TSchema>(\n  schema: Omit<T, 'static' | 'params'>,\n) => schema as T\n"],"names":["applyNames","params","opts","Object","fromEntries","entries","map","k","v","name","createSchema","schema"],"mappings":"AAIA,OAAO,MAAMA,aAAa,CACxBC,QACAC;IAEA,OAAOC,OAAOC,WAAW,CACvBD,OAAOE,OAAO,CAACJ,QAAQK,GAAG,CAAC,CAAC,CAACC,GAAGC,EAAE,GAAK;YAACD;YAAG;gBAAE,GAAGC,CAAC;gBAAEC,MAAMF;gBAAG,GAAGL,IAAI;YAAC;SAAE;AAE1E,EAAC;AAED,OAAO,MAAMQ,eAAe,CAC1BC,SACGA,OAAW"}
+{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["export type ContractSchemaOptions = {\n  title?: string\n  description?: string\n}\n\nexport const applyNames = <T extends Record<string, { serviceName?: string }>>(\n  params: T,\n  opts: { serviceName?: string; subscriptionName?: string },\n) => {\n  return Object.fromEntries(\n    Object.entries(params).map(([k, v]) => [k, { ...v, name: k, ...opts }]),\n  )\n}\n\nexport const createSchema = <T>(schema: T) => schema as T\n"],"names":["applyNames","params","opts","Object","fromEntries","entries","map","k","v","name","createSchema","schema"],"mappings":"AAKA,OAAO,MAAMA,aAAa,CACxBC,QACAC;IAEA,OAAOC,OAAOC,WAAW,CACvBD,OAAOE,OAAO,CAACJ,QAAQK,GAAG,CAAC,CAAC,CAACC,GAAGC,EAAE,GAAK;YAACD;YAAG;gBAAE,GAAGC,CAAC;gBAAEC,MAAMF;gBAAG,GAAGL,IAAI;YAAC;SAAE;AAE1E,EAAC;AAED,OAAO,MAAMQ,eAAe,CAAIC,SAAcA,OAAW"}

package/package.json

@@ -3,28 +3,18 @@
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./src/contract.ts",
-      "default": "./dist/contract.js",
-      "types": "./src/contract.ts"
-    },
-    "./compiler": {
-      "bun": "./src/compiler.ts",
-      "default": "./dist/compiler.js",
-      "types": "./src/compiler.ts"
-    },
-    "./guards": {
-      "bun": "./src/guards.ts",
-      "default": "./dist/guards.js",
-      "types": "./src/guards.ts"
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js",
+      "types": "./src/index.ts"
     }
   },
   "peerDependencies": {
-    "@sinclair/typebox": "^0.32.34",
-    "@nmtjs/common": "0.0.4"
+    "@nmtjs/common": "0.1.1",
+    "@nmtjs/type": "0.1.1"
   },
   "devDependencies": {
-    "@sinclair/typebox": "^0.32.34",
-    "@nmtjs/common": "0.0.4"
+    "@nmtjs/common": "0.1.1",
+    "@nmtjs/type": "0.1.1"
   },
   "files": [
     "src",
@@ -33,7 +23,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.0.4",
+  "version": "0.1.1",
   "scripts": {
     "build": "neemata-build -p neutral --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/index.ts

@@ -0,0 +1,31 @@
+import { t as baseT } from '@nmtjs/type'
+import { EventContract, type TEventContract } from './schemas/event.ts'
+
+import {
+  ProcedureContract,
+  type TBaseProcedureContract,
+  type TProcedureContract,
+} from './schemas/procedure.ts'
+import { ServiceContract, type TServiceContract } from './schemas/service.ts'
+import {
+  SubscriptionContract,
+  type TSubscriptionContract,
+} from './schemas/subscription.ts'
+import { blob } from './types/blob.ts'
+
+export type {
+  TEventContract,
+  TProcedureContract,
+  TBaseProcedureContract,
+  TServiceContract,
+  TSubscriptionContract,
+}
+
+export namespace c {
+  export const procedure = ProcedureContract
+  export const event = EventContract
+  export const subscription = SubscriptionContract
+  export const service = ServiceContract
+}
+
+export const t = Object.assign({}, baseT, { blob })

package/src/schemas/event.ts

@@ -1,35 +1,31 @@
-import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'
+import { type BaseType, type TSchema, getTypeSchema } from '@nmtjs/type'
 import { type ContractSchemaOptions, createSchema } from '../utils.ts'
 
 export const EventKind = 'NeemataEvent'
 
 export interface TEventContract<
-  Payload extends TSchema = any,
+  Payload extends BaseType = BaseType,
   Name extends string | undefined = string | undefined,
   ServiceName extends string | undefined = string | undefined,
   SubscriptionName extends string | undefined = string | undefined,
-> extends TSchema {
-  [Kind]: typeof EventKind
+> {
   type: 'neemata:event'
-  static: {
-    payload: Payload['static']
-  }
   name: Name
   serviceName: ServiceName
   subscriptionName: SubscriptionName
   payload: Payload
 }
 
-export const EventContract = <Payload extends TSchema>(
+export const EventContract = <Payload extends BaseType>(
   payload: Payload,
   schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,
 ) => {
-  if (!TypeRegistry.Has(EventKind)) TypeRegistry.Set(EventKind, () => true)
-
   return createSchema<TEventContract<Payload>>({
     ...schemaOptions,
-    [Kind]: EventKind,
     type: 'neemata:event',
     payload,
+    name: undefined,
+    serviceName: undefined,
+    subscriptionName: undefined,
   })
 }

package/src/schemas/procedure.ts

@@ -1,18 +1,17 @@
-import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'
-
+import type { BaseType } from '@nmtjs/type'
 import { type ContractSchemaOptions, createSchema } from '../utils.ts'
 
-export const ProcedureKind = 'NeemataProcedure'
-
 export interface TBaseProcedureContract<
-  Input extends TSchema = TSchema,
-  Output extends TSchema = TSchema,
+  Type extends string = string,
+  Input extends BaseType = BaseType,
+  Output extends BaseType = BaseType,
   Name extends string | undefined = string | undefined,
   ServiceName extends string | undefined = string | undefined,
   Transports extends { [K in string]?: true } | undefined =
     | { [K in string]?: true }
     | undefined,
-> extends TSchema {
+> {
+  type: Type
   name: Name
   serviceName: ServiceName
   transports: Transports
@@ -22,40 +21,39 @@ export interface TBaseProcedureContract<
 }
 
 export interface TProcedureContract<
-  Input extends TSchema = TSchema,
-  Output extends TSchema = TSchema,
+  Input extends BaseType = BaseType,
+  Output extends BaseType = BaseType,
   Name extends string | undefined = string | undefined,
   ServiceName extends string | undefined = string | undefined,
   Transports extends { [K in string]?: true } | undefined =
     | { [K in string]?: true }
     | undefined,
-> extends TBaseProcedureContract<Input, Output, Name, ServiceName, Transports> {
-  [Kind]: typeof ProcedureKind
-  type: 'neemata:procedure'
-  static: {
-    input: Input['static']
-    output: Output['static']
-  }
-}
+> extends TBaseProcedureContract<
+    'neemata:procedure',
+    Input,
+    Output,
+    Name,
+    ServiceName,
+    Transports
+  > {}
 
 export const ProcedureContract = <
-  Input extends TSchema,
-  Output extends TSchema,
+  Input extends BaseType,
+  Output extends BaseType,
 >(
   input: Input,
   output: Output,
   timeout?: number,
   schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,
 ) => {
-  if (!TypeRegistry.Has(ProcedureKind))
-    TypeRegistry.Set(ProcedureKind, () => true)
-
   return createSchema<TProcedureContract<Input, Output>>({
     ...schemaOptions,
-    [Kind]: ProcedureKind,
     type: 'neemata:procedure',
     input,
     output,
     timeout,
+    name: undefined,
+    serviceName: undefined,
+    transports: undefined,
   })
 }

package/src/schemas/service.ts

@@ -1,54 +1,45 @@
-import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'
 import {
   type ContractSchemaOptions,
   applyNames,
   createSchema,
 } from '../utils.ts'
 import type { TEventContract } from './event.ts'
-import type { TProcedureContract } from './procedure.ts'
-import { SubscriptionKind, type TSubscriptionContract } from './subscription.ts'
-
-export const ServiceKind = 'NeemataService'
+import type { TBaseProcedureContract, TProcedureContract } from './procedure.ts'
+import type { TSubscriptionContract } from './subscription.ts'
 
 export interface TServiceContract<
   Name extends string = string,
   Transports extends { [K in string]?: true } = { [K in string]?: true },
-  Procedures extends Record<
+  Procedures extends Record<string, TBaseProcedureContract> = Record<
     string,
     TProcedureContract | TSubscriptionContract
-  > = Record<string, TProcedureContract | TSubscriptionContract>,
+  >,
   Events extends Record<string, TEventContract> = Record<
     string,
     TEventContract
   >,
-> extends TSchema {
-  [Kind]: typeof ServiceKind
-  static: {
-    procedures: {
-      [K in keyof Procedures]: Procedures[K]['static']
-    }
-    subscriptions: {
-      [K in keyof Procedures]: Procedures[K]['static']
-    }
-    events: {
-      [K in keyof Events]: Events[K]['static']
-    }
-    transports: Transports
-  }
+> {
   type: 'neemata:service'
   name: Name
   transports: Transports
   procedures: {
     [K in keyof Procedures]: Procedures[K] extends TProcedureContract<
       infer Input,
-      infer Output
+      infer Output,
+      any,
+      any,
+      any
     >
-      ? TProcedureContract<Input, Output, Extract<K, string>, Name, Transports>
+      ? // ? true
+        TProcedureContract<Input, Output, Extract<K, string>, Name, Transports>
       : Procedures[K] extends TSubscriptionContract<
             infer Input,
             infer Output,
             infer Options,
-            infer Events
+            infer Events,
+            any,
+            any,
+            any
           >
         ? TSubscriptionContract<
             Input,
@@ -70,14 +61,14 @@ export interface TServiceContract<
             Name,
             Transports
           >
-        : never
+        : Procedures[K]
   }
   events: {
     [K in Extract<keyof Events, string>]: Events[K] extends TEventContract<
       infer Payload
     >
       ? TEventContract<Payload, K, Name>
-      : never
+      : Events[K]
   }
   timeout?: number
 }
@@ -95,12 +86,10 @@ export const ServiceContract = <
   timeout?: number,
   schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,
 ) => {
-  if (!TypeRegistry.Has(ServiceKind)) TypeRegistry.Set(ServiceKind, () => true)
-
   const serviceProcedures = {}
 
   for (const [procedureName, procedure] of Object.entries(procedures)) {
-    if (procedure[Kind] === SubscriptionKind) {
+    if (procedure.type === 'neemata:subscription') {
       serviceProcedures[procedureName] = {
         ...procedure,
         events: applyNames(procedure.events, {
@@ -115,12 +104,33 @@ export const ServiceContract = <
 
   return createSchema<TServiceContract<Name, Transports, Procedures, Events>>({
     ...schemaOptions,
-    [Kind]: ServiceKind,
     name: name,
     type: 'neemata:service',
+    // @ts-expect-error
     procedures: applyNames(procedures, { serviceName: name }),
+    // @ts-expect-error
     events: applyNames(events, { serviceName: name }),
     transports,
     timeout,
   })
 }
+
+type A<T extends boolean> = {
+  // type: 'boolean'
+  a: T
+}
+type B<T extends number> = {
+  // type: 'number'
+  b: T
+}
+type T = Record<string, A<boolean> | B<number>>
+
+type TT<TTT extends T> = {
+  [K in keyof TTT]: TTT[K] extends A<infer T>
+    ? T
+    : TTT[K] extends B<infer T>
+      ? T
+      : never
+}
+
+type TTT = TT<{ r: A<false> }>