@nmtjs/contract 0.0.1

package/dist/utils.js.map

@@ -0,0 +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"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@nmtjs/contract",
+  "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"
+    }
+  },
+  "peerDependencies": {
+    "@sinclair/typebox": "^0.32.34",
+    "@nmtjs/common": "0.0.1"
+  },
+  "devDependencies": {
+    "@sinclair/typebox": "^0.32.34",
+    "@nmtjs/common": "0.0.1"
+  },
+  "files": [
+    "src",
+    "dist",
+    "tsconfig.json",
+    "LICENSE.md",
+    "README.md"
+  ],
+  "version": "0.0.1",
+  "scripts": {
+    "build": "neemata-build -p neutral --root=./src './**/*.ts'",
+    "type-check": "tsc --noEmit"
+  }
+}

package/src/compiler.ts

@@ -0,0 +1,63 @@
+import {
+  type TypeCheck,
+  TypeCompiler,
+  type ValueErrorIterator,
+} from '@sinclair/typebox/compiler'
+import type { TSchema } from '@sinclair/typebox/type'
+import { Value } from '@sinclair/typebox/value'
+
+export type Compiled = {
+  check: (val: unknown) => boolean
+  errors: (val: unknown) => ValueErrorIterator
+  decode: (
+    val: unknown,
+  ) => { success: true; value: unknown } | { success: false; error: any }
+  encode: (
+    val: unknown,
+  ) => { success: true; value: unknown } | { success: false; error: any }
+}
+
+const compileSchema = (
+  schema: TSchema,
+): TypeCheck<TSchema> & {
+  Prepare: (value: any) => unknown
+} => {
+  const compiled = TypeCompiler.Compile(schema)
+  const Prepare = (value: any) => {
+    for (const fn of [Value.Clean, Value.Default]) {
+      value = fn(schema, value)
+    }
+    return value
+  }
+  return Object.assign(compiled, { Prepare })
+}
+
+export const compile = (schema: TSchema): Compiled => {
+  const compiled = compileSchema(schema)
+
+  // TODO: custom error handling/shaping
+  return {
+    check: compiled.Check.bind(compiled),
+    errors: compiled.Errors.bind(compiled),
+    decode: (val) => {
+      try {
+        return {
+          success: true as const,
+          value: compiled.Decode(compiled.Prepare(val)),
+        }
+      } catch (error) {
+        return { success: false as const, error }
+      }
+    },
+    encode: (val) => {
+      try {
+        return {
+          success: true as const,
+          value: compiled.Encode(compiled.Prepare(val)),
+        }
+      } catch (error) {
+        return { success: false as const, error }
+      }
+    },
+  }
+}

package/src/contract.ts

@@ -0,0 +1,62 @@
+import {
+  JsonTypeBuilder,
+  Kind,
+  type StaticDecode,
+  type StaticEncode,
+  type TSchema,
+} from '@sinclair/typebox/type'
+import { register } from './formats.ts' // register ajv formats
+
+import { BlobType, type TBlob } from './schemas/blob.ts'
+import { EventContract, type TEventContract } from './schemas/event.ts'
+import { NativeEnum, type TNativeEnum } from './schemas/native-enum.ts'
+import { Nullable } from './schemas/nullable.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 { type TUnionEnum, UnionEnum } from './schemas/union-enum.ts'
+
+register()
+
+const Contract = Object.freeze({
+  Procedure: ProcedureContract,
+  Event: EventContract,
+  Subscription: SubscriptionContract,
+  Service: ServiceContract,
+})
+
+const Type = Object.freeze(
+  Object.assign(new JsonTypeBuilder(), {
+    UnionEnum,
+    NativeEnum,
+    Nullable,
+    Blob: BlobType,
+  }),
+)
+
+type Encoded<T extends TSchema> = StaticEncode<T>
+type Decoded<T extends TSchema> = StaticDecode<T>
+
+export {
+  Contract,
+  Kind,
+  Type,
+  type Decoded,
+  type Encoded,
+  type TBlob,
+  type TEventContract,
+  type TProcedureContract,
+  type TBaseProcedureContract,
+  type TSchema,
+  type TServiceContract,
+  type TSubscriptionContract,
+  type TUnionEnum,
+  type TNativeEnum,
+}

package/src/formats.ts

@@ -0,0 +1,181 @@
+import { FormatRegistry } from '@sinclair/typebox/type'
+
+// TODO: review all of this
+
+export const register = () => {
+  for (const [name, format] of Object.entries(fullFormats)) {
+    if (format === true) {
+      FormatRegistry.Set(name, () => true)
+      continue
+    }
+
+    if (typeof format === 'function') {
+      FormatRegistry.Set(name, format)
+      continue
+    }
+
+    FormatRegistry.Set(name, (value) => format.test(value))
+  }
+}
+
+export const fullFormats: Record<
+  string,
+  RegExp | ((v: any) => boolean) | true
+> = {
+  // date: http://tools.ietf.org/html/rfc3339#section-5.6
+  date,
+  // date-time: http://tools.ietf.org/html/rfc3339#section-5.6
+  time: getTime(true),
+  'date-time': getDateTime(true),
+  'iso-time': getTime(),
+  'iso-date-time': getDateTime(),
+  // duration: https://tools.ietf.org/html/rfc3339#appendix-A
+  duration:
+    /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
+  uri,
+  'uri-reference':
+    /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
+  // uri-template: https://tools.ietf.org/html/rfc6570
+  'uri-template':
+    // biome-ignore lint/suspicious/noControlCharactersInRegex:
+    /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
+  // For the source: https://gist.github.com/dperini/729294
+  // For test cases: https://mathiasbynens.be/demo/url-regex
+  url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
+  email:
+    /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
+  hostname:
+    /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
+  // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
+  ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
+  ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
+  regex,
+  // uuid: http://tools.ietf.org/html/rfc4122
+  uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
+  // JSON-pointer: https://tools.ietf.org/html/rfc6901
+  // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
+  'json-pointer': /^(?:\/(?:[^~/]|~0|~1)*)*$/,
+  'json-pointer-uri-fragment':
+    /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
+  // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00
+  'relative-json-pointer': /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
+  // the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types
+  // byte: https://github.com/miguelmota/is-base64
+  byte,
+  // signed 32 bit integer
+  int32: validateInt32,
+  // signed 64 bit integer
+  int64: validateInt64,
+  // C-type float
+  float: validateNumber,
+  // C-type double
+  double: validateNumber,
+  // hint to the UI to hide input strings
+  password: true,
+  // unchecked string payload
+  binary: true,
+}
+
+function isLeapYear(year: number): boolean {
+  // https://tools.ietf.org/html/rfc3339#appendix-C
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
+}
+
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+function date(str: string): boolean {
+  // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
+  const matches: string[] | null = DATE.exec(str)
+  if (!matches) return false
+  const year: number = +matches[1]
+  const month: number = +matches[2]
+  const day: number = +matches[3]
+  return (
+    month >= 1 &&
+    month <= 12 &&
+    day >= 1 &&
+    day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month])
+  )
+}
+
+const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i
+
+function getTime(strictTimeZone?: boolean): (str: string) => boolean {
+  return function time(str: string): boolean {
+    const matches: string[] | null = TIME.exec(str)
+    if (!matches) return false
+    const hr: number = +matches[1]
+    const min: number = +matches[2]
+    const sec: number = +matches[3]
+    const tz: string | undefined = matches[4]
+    const tzSign: number = matches[5] === '-' ? -1 : 1
+    const tzH: number = +(matches[6] || 0)
+    const tzM: number = +(matches[7] || 0)
+    if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false
+    if (hr <= 23 && min <= 59 && sec < 60) return true
+    // leap second
+    const utcMin = min - tzM * tzSign
+    const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)
+    return (
+      (utcHr === 23 || utcHr === -1) &&
+      (utcMin === 59 || utcMin === -1) &&
+      sec < 61
+    )
+  }
+}
+
+const DATE_TIME_SEPARATOR = /t|\s/i
+function getDateTime(strictTimeZone?: boolean): (str: string) => boolean {
+  const time = getTime(strictTimeZone)
+
+  return function date_time(str: string): boolean {
+    // http://tools.ietf.org/html/rfc3339#section-5.6
+    const dateTime: string[] = str.split(DATE_TIME_SEPARATOR)
+    return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1])
+  }
+}
+
+const NOT_URI_FRAGMENT = /\/|:/
+const URI =
+  /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i
+
+function uri(str: string): boolean {
+  // http://jmrware.com/articles/2009/uri_regexp/URI_regex.html + optional protocol + required "."
+  return NOT_URI_FRAGMENT.test(str) && URI.test(str)
+}
+
+const BYTE =
+  /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm
+
+function byte(str: string): boolean {
+  BYTE.lastIndex = 0
+  return BYTE.test(str)
+}
+
+const MIN_INT32 = -(2 ** 31)
+const MAX_INT32 = 2 ** 31 - 1
+
+function validateInt32(value: number): boolean {
+  return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32
+}
+
+function validateInt64(value: number): boolean {
+  // JSON and javascript max Int is 2**53, so any int that passes isInteger is valid for Int64
+  return Number.isInteger(value)
+}
+
+function validateNumber(): boolean {
+  return true
+}
+
+const Z_ANCHOR = /[^\\]\\Z/
+function regex(str: string): boolean {
+  if (Z_ANCHOR.test(str)) return false
+  try {
+    new RegExp(str)
+    return true
+  } catch (e) {
+    return false
+  }
+}

package/src/guards/blob.ts

@@ -0,0 +1,5 @@
+import { KindGuard, type TSchema } from '@sinclair/typebox'
+import { BlobKind, type TBlob } from '../schemas/blob.ts'
+
+export const IsBlob = (schema: TSchema): schema is TBlob =>
+  KindGuard.IsKindOf(schema, BlobKind)

package/src/guards/event.ts

@@ -0,0 +1,6 @@
+import { KindGuard, type TSchema } from '@sinclair/typebox'
+
+import { EventKind, type TEventContract } from '../schemas/event.ts'
+
+export const IsEvent = (schema: TSchema): schema is TEventContract =>
+  KindGuard.IsKindOf(schema, EventKind)

package/src/guards/native-enum.ts

@@ -0,0 +1,7 @@
+import { KindGuard, type TSchema } from '@sinclair/typebox'
+import { NativeEnumKind, type TNativeEnum } from '../schemas/native-enum.ts'
+
+export const IsNativeEnum = (
+  schema: TSchema,
+): schema is TNativeEnum<Record<string, string>> =>
+  KindGuard.IsKindOf(schema, NativeEnumKind)

package/src/guards/nullable.ts

@@ -0,0 +1,14 @@
+import {
+  KindGuard,
+  type TNull,
+  type TSchema,
+  type TUnion,
+} from '@sinclair/typebox'
+
+export const IsNullable = (
+  schema: TSchema,
+): schema is TUnion<[TSchema, TNull]> =>
+  KindGuard.IsUnion(schema) &&
+  schema.anyOf.length === 2 &&
+  KindGuard.IsNull(schema.anyOf[1]) &&
+  KindGuard.IsSchema(schema.anyOf[0])

package/src/guards/procedure.ts

@@ -0,0 +1,6 @@
+import { KindGuard, type TSchema } from '@sinclair/typebox'
+
+import { ProcedureKind, type TProcedureContract } from '../schemas/procedure.ts'
+
+export const IsProcedure = (schema: TSchema): schema is TProcedureContract =>
+  KindGuard.IsKindOf(schema, ProcedureKind)

package/src/guards/service.ts

@@ -0,0 +1,6 @@
+import { KindGuard, type TSchema } from '@sinclair/typebox'
+
+import { ServiceKind, type TServiceContract } from '../schemas/service.ts'
+
+export const IsService = (schema: TSchema): schema is TServiceContract =>
+  KindGuard.IsKindOf(schema, ServiceKind)

package/src/guards/subscription.ts

@@ -0,0 +1,10 @@
+import { KindGuard, type TSchema } from '@sinclair/typebox'
+import {
+  SubscriptionKind,
+  type TSubscriptionContract,
+} from '../schemas/subscription.ts'
+
+export const IsSubscription = (
+  schema: TSchema,
+): schema is TSubscriptionContract =>
+  KindGuard.IsKindOf(schema, SubscriptionKind)

package/src/guards/union-enum.ts

@@ -0,0 +1,7 @@
+import { KindGuard, type TSchema } from '@sinclair/typebox'
+import { type TUnionEnum, UnionEnumKind } from '../schemas/union-enum.ts'
+
+export const IsUnionEnum = (
+  schema: TSchema,
+): schema is TUnionEnum<(string | number)[]> =>
+  KindGuard.IsKindOf(schema, UnionEnumKind)

package/src/guards.ts

@@ -0,0 +1,21 @@
+import { KindGuard } from '@sinclair/typebox'
+import { IsBlob } from './guards/blob.ts'
+import { IsEvent } from './guards/event.ts'
+import { IsNativeEnum } from './guards/native-enum.ts'
+import { IsNullable } from './guards/nullable.ts'
+import { IsProcedure } from './guards/procedure.ts'
+import { IsService } from './guards/service.ts'
+import { IsSubscription } from './guards/subscription.ts'
+import { IsUnionEnum } from './guards/union-enum.ts'
+
+export const ContractGuard = {
+  ...KindGuard,
+  IsEvent,
+  IsSubscription,
+  IsProcedure,
+  IsService,
+  IsBlob,
+  IsNullable,
+  IsUnionEnum,
+  IsNativeEnum,
+}

package/src/schemas/blob.ts

@@ -0,0 +1,58 @@
+import { ApiBlob, type ApiBlobInterface } from '@nmtjs/common'
+import {
+  Kind,
+  type TSchema,
+  Type,
+  TypeBoxError,
+  TypeRegistry,
+} from '@sinclair/typebox/type'
+import { type ContractSchemaOptions, createSchema } from '../utils.ts'
+
+export const BlobKind = 'ApiBlob'
+
+export type BlobOptions = {
+  maxSize?: number
+  contentType?: string
+}
+
+export interface TBlob extends TSchema {
+  [Kind]: typeof BlobKind
+  type: 'neemata:blob'
+  static: ApiBlobInterface
+  maxSize?: BlobOptions['maxSize']
+  contentType?: BlobOptions['contentType']
+}
+
+export const BlobType = (
+  options: BlobOptions = {},
+  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,
+) => {
+  if (!TypeRegistry.Has(BlobKind)) {
+    TypeRegistry.Set(BlobKind, (schema: TBlob, value) => {
+      return 'metadata' in (value as any)
+    })
+  }
+
+  return Type.Transform(
+    createSchema<TBlob>({
+      ...schemaOptions,
+      [Kind]: BlobKind,
+      type: 'neemata:blob',
+      ...options,
+    }),
+  )
+    .Decode((value) => {
+      if ('metadata' in value) {
+        if (options.maxSize) {
+          const size = (value as ApiBlobInterface).metadata.size
+          if (size === -1 || size > options.maxSize) {
+            throw new TypeBoxError(
+              'Blob size unknown or exceeds maximum allowed size',
+            )
+          }
+        }
+      }
+      return value
+    })
+    .Encode((value) => value) as unknown as TBlob
+}

package/src/schemas/event.ts

@@ -0,0 +1,35 @@
+import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'
+import { type ContractSchemaOptions, createSchema } from '../utils.ts'
+
+export const EventKind = 'NeemataEvent'
+
+export interface TEventContract<
+  Payload extends TSchema = any,
+  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>(
+  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,
+  })
+}

package/src/schemas/native-enum.ts

@@ -0,0 +1,37 @@
+import {
+  Kind,
+  type SchemaOptions,
+  type TSchema,
+  TypeRegistry,
+} from '@sinclair/typebox/type'
+
+export const NativeEnumKind = 'NativeEnum'
+
+// -------------------------------------------------------------------------------------
+// TNativeEnum
+// -------------------------------------------------------------------------------------
+export interface TNativeEnum<T extends Record<string, string>> extends TSchema {
+  [Kind]: typeof NativeEnumKind
+  static: T[keyof T][]
+  enum: T[keyof T][]
+}
+
+// -------------------------------------------------------------------------------------
+// NativeEnum
+// -------------------------------------------------------------------------------------
+/** `[Experimental]` Creates a Union type with a `enum` schema representation  */
+export function NativeEnum<T extends Record<string, string>>(
+  value: T,
+  options: SchemaOptions = {},
+) {
+  const values = Object.values(value)
+
+  function NativeEnumCheck(schema: TNativeEnum<T>, value: unknown) {
+    return typeof value === 'string' && schema.enum.includes(value as any)
+  }
+
+  if (!TypeRegistry.Has(NativeEnumKind))
+    TypeRegistry.Set(NativeEnumKind, NativeEnumCheck)
+
+  return { ...options, [Kind]: NativeEnumKind, enum: values } as TNativeEnum<T>
+}

package/src/schemas/nullable.ts

@@ -0,0 +1,4 @@
+import { type TSchema, Type } from '@sinclair/typebox/type'
+
+export const Nullable = <T extends TSchema>(schema: T) =>
+  Type.Union([schema, Type.Null()])

package/src/schemas/procedure.ts

@@ -0,0 +1,61 @@
+import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'
+
+import { type ContractSchemaOptions, createSchema } from '../utils.ts'
+
+export const ProcedureKind = 'NeemataProcedure'
+
+export interface TBaseProcedureContract<
+  Input extends TSchema = TSchema,
+  Output extends TSchema = TSchema,
+  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 {
+  name: Name
+  serviceName: ServiceName
+  transports: Transports
+  input: Input
+  output: Output
+  timeout?: number
+}
+
+export interface TProcedureContract<
+  Input extends TSchema = TSchema,
+  Output extends TSchema = TSchema,
+  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']
+  }
+}
+
+export const ProcedureContract = <
+  Input extends TSchema,
+  Output extends TSchema,
+>(
+  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,
+  })
+}