@loomcore/common 0.0.1

package/dist/errors/custom.error.js

@@ -0,0 +1,6 @@
+export class CustomError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, CustomError.prototype);
+    }
+}

package/dist/errors/index.js

@@ -0,0 +1,2 @@
+export * from './custom.error.js';
+export * from './validation.error.js';

package/dist/errors/validation.error.js

@@ -0,0 +1,26 @@
+import { CustomError } from './custom.error.js';
+export class ValidationError extends CustomError {
+    statusCode = 400;
+    validationError;
+    constructor(validationError) {
+        if (Array.isArray(validationError)) {
+            super(validationError[0]?.message || 'Validation Error');
+        }
+        else {
+            super('Validation Error');
+        }
+        this.validationError = validationError;
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+    serializeErrors() {
+        if (Array.isArray(this.validationError)) {
+            return this.validationError.map((error) => {
+                return {
+                    message: error.message,
+                    field: error.path.slice(1)
+                };
+            });
+        }
+        return [{ message: 'Validation Error' }];
+    }
+}

package/dist/models/address.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/models/api-response.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/models/auditable.model.js

@@ -0,0 +1,8 @@
+import { Type } from '@sinclair/typebox';
+import { TypeboxIsoDate } from '../validation/index.js';
+export const AuditableSchema = Type.Object({
+    _created: TypeboxIsoDate(),
+    _createdBy: Type.String(),
+    _updated: TypeboxIsoDate(),
+    _updatedBy: Type.String(),
+});

package/dist/models/entity.model.js

@@ -0,0 +1,6 @@
+import { Type } from '@sinclair/typebox';
+import { TypeboxObjectId } from "../validation/index.js";
+export const EntitySchema = Type.Object({
+    _id: TypeboxObjectId({ title: 'ID' }),
+    _orgId: Type.Optional(Type.String({ title: 'Organization ID' }))
+});

package/dist/models/error.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/models/geo-json.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/models/index.js

@@ -0,0 +1,15 @@
+export * from './user.model.js';
+export * from './organization.model.js';
+export * from './user-context.model.js';
+export * from './entity.model.js';
+export * from './login-response.model.js';
+export * from './token-response.model.js';
+export * from './auditable.model.js';
+export * from './query-options.model.js';
+export * from './password-reset-token.interface.js';
+export * from './model-spec.interface.js';
+export * from './paged-result.interface.js';
+export * from './geo-json.interface.js';
+export * from './address.interface.js';
+export * from './error.interface.js';
+export * from './api-response.interface.js';

package/dist/models/login-response.model.js

@@ -0,0 +1,9 @@
+import { TokenResponseSchema } from './token-response.model.js';
+import { Type } from '@sinclair/typebox';
+import { UserContextSchema } from './user-context.model.js';
+import { entityUtils } from '../utils/entity.utils.js';
+export const LoginResponseSchema = Type.Object({
+    tokens: TokenResponseSchema,
+    userContext: UserContextSchema
+});
+export const LoginResponseSpec = entityUtils.getModelSpec(LoginResponseSchema);

package/dist/models/model-spec.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/models/organization.model.js

@@ -0,0 +1,24 @@
+import { Type } from '@sinclair/typebox';
+import { entityUtils } from '../utils/index.js';
+export const OrganizationSchema = Type.Object({
+    name: Type.String({
+        title: 'Name'
+    }),
+    code: Type.String({
+        title: 'Code'
+    }),
+    description: Type.Optional(Type.String({
+        title: 'Description'
+    })),
+    status: Type.Number({
+        title: 'Status'
+    }),
+    isMetaOrg: Type.Boolean({
+        title: 'Is Meta Organization',
+        default: false
+    }),
+    authToken: Type.Optional(Type.String({
+        title: 'Authentication Token'
+    }))
+});
+export const OrganizationSpec = entityUtils.getModelSpec(OrganizationSchema, { isAuditable: true });

package/dist/models/paged-result.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/models/password-reset-token.interface.js

@@ -0,0 +1,15 @@
+import { Type } from '@sinclair/typebox';
+import { entityUtils } from '../utils/index.js';
+export const PasswordResetTokenSchema = Type.Object({
+    email: Type.String({
+        title: 'Email',
+        format: 'email'
+    }),
+    token: Type.String({
+        title: 'Token'
+    }),
+    expiresOn: Type.Number({
+        title: 'Expires On'
+    })
+});
+export const PasswordResetTokenSpec = entityUtils.getModelSpec(PasswordResetTokenSchema, { isAuditable: true });

package/dist/models/query-options.model.js

@@ -0,0 +1,14 @@
+export class QueryOptions {
+    orderBy;
+    sortDirection;
+    page;
+    pageSize;
+    filters;
+    constructor(options = {}) {
+        this.orderBy = options.orderBy;
+        this.sortDirection = options.sortDirection ?? 'asc';
+        this.page = options.page ?? 1;
+        this.pageSize = options.pageSize ?? 10;
+        this.filters = options.filters;
+    }
+}

package/dist/models/token-response.model.js

@@ -0,0 +1,8 @@
+import { Type } from '@sinclair/typebox';
+import { entityUtils } from '../utils/entity.utils.js';
+export const TokenResponseSchema = Type.Object({
+    accessToken: Type.String(),
+    refreshToken: Type.String(),
+    expiresOn: Type.Number()
+});
+export const TokenResponseSpec = entityUtils.getModelSpec(TokenResponseSchema);

package/dist/models/user-context.model.js

@@ -0,0 +1,12 @@
+import { Type } from '@sinclair/typebox';
+import { PublicUserSchema } from './user.model.js';
+import { entityUtils } from '../utils/entity.utils.js';
+export const EmptyUserContext = {
+    user: {},
+    _orgId: undefined
+};
+export const UserContextSchema = Type.Object({
+    user: PublicUserSchema,
+    _orgId: Type.Optional(Type.String())
+});
+export const UserContextSpec = entityUtils.getModelSpec(UserContextSchema);

package/dist/models/user.model.js

@@ -0,0 +1,35 @@
+import { TypeboxIsoDate } from '../validation/typebox-extensions.js';
+import { Type } from '@sinclair/typebox';
+import { entityUtils } from '../utils/entity.utils.js';
+import { TypeCompiler } from '@sinclair/typebox/compiler';
+export const UserPasswordSchema = Type.Object({
+    password: Type.String({
+        title: 'Password',
+        minLength: 6,
+        maxLength: 30
+    }),
+});
+export const passwordValidator = TypeCompiler.Compile(UserPasswordSchema);
+export const UserSchema = Type.Object({
+    email: Type.String({
+        title: 'Email',
+        format: 'email'
+    }),
+    firstName: Type.Optional(Type.String({
+        title: 'First Name'
+    })),
+    lastName: Type.Optional(Type.String({
+        title: 'Last Name'
+    })),
+    displayName: Type.Optional(Type.String({
+        title: 'Display Name'
+    })),
+    password: UserPasswordSchema.properties.password,
+    roles: Type.Optional(Type.Array(Type.String({
+        title: 'Roles',
+    }))),
+    _lastLoggedIn: Type.Optional(TypeboxIsoDate({ title: 'Last Login Date' })),
+    _lastPasswordChange: Type.Optional(TypeboxIsoDate({ title: 'Last Password Change Date' })),
+});
+export const UserSpec = entityUtils.getModelSpec(UserSchema, { isAuditable: true });
+export const PublicUserSchema = Type.Omit(UserSpec.fullSchema, ['password']);

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from './sort-direction.type.js';

package/dist/types/sort-direction.type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/entity.utils.js

@@ -0,0 +1,102 @@
+import { ValidationError } from '../errors/index.js';
+import { Type } from '@sinclair/typebox';
+import { TypeCompiler } from '@sinclair/typebox/compiler';
+import { EntitySchema } from '../models/entity.model.js';
+import { AuditableSchema } from '../models/auditable.model.js';
+import { Value } from '@sinclair/typebox/value';
+function getValidator(schema) {
+    const validator = TypeCompiler.Compile(schema);
+    return validator;
+}
+function getModelSpec(schema, options = {}) {
+    const partialSchema = Type.Partial(schema);
+    const schemasToIntersect = [];
+    schemasToIntersect.push(schema);
+    schemasToIntersect.push(EntitySchema);
+    if (options.isAuditable) {
+        schemasToIntersect.push(AuditableSchema);
+    }
+    const fullSchema = Type.Intersect(schemasToIntersect);
+    const validator = getValidator(schema);
+    const partialValidator = getValidator(partialSchema);
+    const fullValidator = getValidator(fullSchema);
+    const encode = (entity, overrideSchema) => {
+        if (entity === null || entity === undefined) {
+            return entity;
+        }
+        const schemaToUse = overrideSchema || fullSchema;
+        return Value.Parse(['Encode', 'Clean'], schemaToUse, entity);
+    };
+    const decode = (entity) => {
+        if (entity === null || entity === undefined) {
+            return entity;
+        }
+        return Value.Parse(['Clean', 'Default', 'Convert', 'Decode'], fullSchema, entity);
+    };
+    const clean = (entity) => {
+        if (!entity)
+            return entity;
+        return Value.Clean(fullSchema, entity);
+    };
+    return {
+        schema,
+        partialSchema,
+        fullSchema,
+        validator,
+        partialValidator,
+        fullValidator,
+        isAuditable: !!options.isAuditable,
+        isMultiTenant: !!options.isMultiTenant,
+        encode,
+        decode,
+        clean
+    };
+}
+function validate(validator, data) {
+    const valid = validator.Check(data);
+    if (!valid) {
+        const errors = [...validator.Errors(data)];
+        return errors;
+    }
+    return null;
+}
+function handleValidationResult(validationErrors, methodName) {
+    if (validationErrors) {
+        throw new ValidationError(validationErrors);
+    }
+}
+function isValidObjectId(id) {
+    let result = false;
+    if (typeof id === 'string' || id instanceof String) {
+        result = id.match(/^[0-9a-fA-F]{24}$/) ? true : false;
+    }
+    else {
+        console.log(`entityUtils.isValidObjectId called with something other than a string. id = ${id}`);
+        console.log(`typeof id = ${typeof id}`);
+        console.log('id = ', id);
+    }
+    return result;
+}
+function isAuditable(entity) {
+    return entity !== null &&
+        typeof entity === 'object' &&
+        (entity.hasOwnProperty('_created') ||
+            entity.hasOwnProperty('_createdBy') ||
+            entity.hasOwnProperty('_updated') ||
+            entity.hasOwnProperty('_updatedBy'));
+}
+function isDecimalMultipleOf(value, multipleOf, precision = 2) {
+    const scale = Math.pow(10, precision);
+    const scaledValue = Math.round(value * scale);
+    const scaledMultipleOf = Math.round(multipleOf * scale);
+    return scaledValue % scaledMultipleOf === 0;
+}
+export const entityUtils = {
+    handleValidationResult,
+    isValidObjectId,
+    isAuditable,
+    getValidator,
+    getModelSpec,
+    validate,
+    isDecimalMultipleOf
+};

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from './entity.utils.js';

package/dist/validation/formats/date-time.js

@@ -0,0 +1,7 @@
+import { IsDate } from './date.js';
+import { IsTime } from './time.js';
+const DATE_TIME_SEPARATOR = /t|\s/i;
+export function IsDateTime(value, strictTimeZone) {
+    const dateTime = value.split(DATE_TIME_SEPARATOR);
+    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone);
+}

package/dist/validation/formats/date.js

@@ -0,0 +1,14 @@
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+function IsLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+export function IsDate(value) {
+    const matches = DATE.exec(value);
+    if (!matches)
+        return false;
+    const year = +matches[1];
+    const month = +matches[2];
+    const day = +matches[3];
+    return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month]);
+}

package/dist/validation/formats/email.js

@@ -0,0 +1,4 @@
+const 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;
+export function IsEmail(value) {
+    return Email.test(value);
+}

package/dist/validation/formats/objectid.js

@@ -0,0 +1,3 @@
+export function IsObjectId(value) {
+    return /^[0-9a-fA-F]{24}$/.test(value);
+}

package/dist/validation/formats/time.js

@@ -0,0 +1,20 @@
+const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
+export function IsTime(value, strictTimeZone) {
+    const matches = TIME.exec(value);
+    if (!matches)
+        return false;
+    const hr = +matches[1];
+    const min = +matches[2];
+    const sec = +matches[3];
+    const tz = matches[4];
+    const tzSign = matches[5] === '-' ? -1 : 1;
+    const tzH = +(matches[6] || 0);
+    const tzM = +(matches[7] || 0);
+    if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz))
+        return false;
+    if (hr <= 23 && min <= 59 && sec < 60)
+        return true;
+    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;
+}

package/dist/validation/index.js

@@ -0,0 +1,5 @@
+export * from './typebox-setup.js';
+export * from './typebox-extensions.js';
+export * from './formats/date.js';
+export * from './formats/time.js';
+export * from './formats/date-time.js';

package/dist/validation/typebox-extensions.js

@@ -0,0 +1,65 @@
+import { Type, Kind, ValueGuard } from '@sinclair/typebox';
+import { TypeRegistry } from '@sinclair/typebox';
+import { Decimal as _Decimal } from 'decimal.js';
+import { Value } from '@sinclair/typebox/value';
+export function TypeboxIsoDate(options = {}) {
+    return Type.Transform(Type.String({ format: 'date-time', ...options }))
+        .Decode(value => new Date(value))
+        .Encode(value => value.toISOString());
+}
+export function TypeboxDate(options = {}) {
+    return Type.Transform(Type.String({ format: 'date', ...options }))
+        .Decode(value => {
+        const date = new Date(value);
+        date.setUTCHours(0, 0, 0, 0);
+        return date;
+    })
+        .Encode(value => {
+        return value.toISOString().split('T')[0];
+    });
+}
+export function TypeboxObjectId(options = {}) {
+    return Type.String({
+        format: 'objectid',
+        ...options
+    });
+}
+export function TypeboxDecimal(options = {}) {
+    return { ...options, [Kind]: 'Decimal', type: 'number' };
+}
+TypeRegistry.Set('Decimal', (schema, value) => {
+    return ((ValueGuard.IsNumber(value)) &&
+        (ValueGuard.IsNumber(schema.multipleOf) ? new _Decimal(value).mod(new _Decimal(schema.multipleOf)).equals(0) : true) &&
+        (ValueGuard.IsNumber(schema.exclusiveMaximum) ? value < schema.exclusiveMaximum : true) &&
+        (ValueGuard.IsNumber(schema.exclusiveMinimum) ? value > schema.exclusiveMinimum : true) &&
+        (ValueGuard.IsNumber(schema.maximum) ? value <= schema.maximum : true) &&
+        (ValueGuard.IsNumber(schema.minimum) ? value >= schema.minimum : true));
+});
+export function TypeboxMoney(options = {}) {
+    return TypeboxDecimal({
+        multipleOf: 0.01,
+        ...options
+    });
+}
+export function TypeboxPercentage(options = {}) {
+    return TypeboxDecimal({
+        minimum: 0,
+        maximum: 100,
+        ...options
+    });
+}
+export function testMoneyType() {
+    const schema = Type.Object({
+        price: TypeboxMoney({ minimum: 0 })
+    });
+    const valid = Value.Check(schema, { price: 39.99 });
+    console.log('39.99 is valid:', valid);
+    const valid2 = Value.Check(schema, { price: 100.00 });
+    console.log('100.00 is valid:', valid2);
+    const invalid = Value.Check(schema, { price: 39.999 });
+    console.log('39.999 is valid:', invalid);
+    if (!invalid) {
+        const errors = [...Value.Errors(schema, { price: 39.999 })];
+        console.log('Validation errors:', errors);
+    }
+}

package/dist/validation/typebox-setup.js

@@ -0,0 +1,161 @@
+import { ObjectId } from 'mongodb';
+import { ValueErrorType, SetErrorFunction } from '@sinclair/typebox/errors';
+import { Kind } from '@sinclair/typebox';
+import { FormatRegistry } from '@sinclair/typebox';
+import { IsDateTime } from './formats/date-time.js';
+import { IsDate } from './formats/date.js';
+import './typebox-extensions.js';
+import { IsEmail } from './formats/email.js';
+import { IsObjectId } from './formats/objectid.js';
+export const isValidObjectId = (value) => {
+    try {
+        return ObjectId.isValid(value) &&
+            new ObjectId(value).toString() === value;
+    }
+    catch {
+        return false;
+    }
+};
+export const initializeTypeBox = () => {
+    SetErrorFunction(customSetErrorFunction);
+    FormatRegistry.Set('objectid', value => IsObjectId(value));
+    FormatRegistry.Set('date-time', value => IsDateTime(value));
+    FormatRegistry.Set('date', value => IsDate(value));
+    FormatRegistry.Set('email', value => IsEmail(value));
+};
+const customSetErrorFunction = (error) => {
+    const formattedPath = error.path === '' ? 'value' : error.path;
+    const fieldName = error.schema.title || formattedPath;
+    switch (error.errorType) {
+        case ValueErrorType.ArrayContains:
+            return `${fieldName} must be an error to contain at least one matching value`;
+        case ValueErrorType.ArrayMaxContains:
+            return `${fieldName} must contain no more than ${error.schema.maxContains} matching values`;
+        case ValueErrorType.ArrayMinContains:
+            return `${fieldName} must contain at least ${error.schema.minContains} matching values`;
+        case ValueErrorType.ArrayMaxItems:
+            return `${fieldName} length to be less or equal to ${error.schema.maxItems}`;
+        case ValueErrorType.ArrayMinItems:
+            return `${fieldName} length to be greater or equal to ${error.schema.minItems}`;
+        case ValueErrorType.ArrayUniqueItems:
+            return `${fieldName} elements must be unique`;
+        case ValueErrorType.Array:
+            return `${fieldName} must be an array`;
+        case ValueErrorType.AsyncIterator:
+            return `${fieldName} must be an AsyncIterator`;
+        case ValueErrorType.BigIntExclusiveMaximum:
+            return `${fieldName} value must be less than ${error.schema.exclusiveMaximum}`;
+        case ValueErrorType.BigIntExclusiveMinimum:
+            return `${fieldName} value must be greater than ${error.schema.exclusiveMinimum}`;
+        case ValueErrorType.BigIntMaximum:
+            return `${fieldName} value must be less or equal to ${error.schema.maximum}`;
+        case ValueErrorType.BigIntMinimum:
+            return `${fieldName} value must be greater or equal to ${error.schema.minimum}`;
+        case ValueErrorType.BigIntMultipleOf:
+            return `${fieldName} value must be a multiple of ${error.schema.multipleOf}`;
+        case ValueErrorType.BigInt:
+            return `${fieldName} must be bigint`;
+        case ValueErrorType.Boolean:
+            return `${fieldName} must be boolean`;
+        case ValueErrorType.DateExclusiveMinimumTimestamp:
+            return `${fieldName} Date must be greater than ${error.schema.exclusiveMinimumTimestamp}`;
+        case ValueErrorType.DateExclusiveMaximumTimestamp:
+            return `${fieldName} Date must be less than ${error.schema.exclusiveMaximumTimestamp}`;
+        case ValueErrorType.DateMinimumTimestamp:
+            return `${fieldName} Date timestamp must be greater or equal to ${error.schema.minimumTimestamp}`;
+        case ValueErrorType.DateMaximumTimestamp:
+            return `${fieldName} Date timestamp must be less or equal to ${error.schema.maximumTimestamp}`;
+        case ValueErrorType.DateMultipleOfTimestamp:
+            return `${fieldName} Date timestamp must be a multiple of ${error.schema.multipleOfTimestamp}`;
+        case ValueErrorType.Date:
+            return `${fieldName} must be a Date`;
+        case ValueErrorType.Function:
+            return `${fieldName} must be a function`;
+        case ValueErrorType.IntegerExclusiveMaximum:
+            return `${fieldName} must be less than ${error.schema.exclusiveMaximum}`;
+        case ValueErrorType.IntegerExclusiveMinimum:
+            return `${fieldName} must be greater than ${error.schema.exclusiveMinimum}`;
+        case ValueErrorType.IntegerMaximum:
+            return `${fieldName} must be less than or equal to ${error.schema.maximum}`;
+        case ValueErrorType.IntegerMinimum:
+            return `${fieldName} must be greater than or equal to ${error.schema.minimum}`;
+        case ValueErrorType.IntegerMultipleOf:
+            return `${fieldName} must be a multiple of ${error.schema.multipleOf}`;
+        case ValueErrorType.Integer:
+            return `${fieldName} must be an integer`;
+        case ValueErrorType.IntersectUnevaluatedProperties:
+            return `${fieldName} property must exist`;
+        case ValueErrorType.Intersect:
+            return `${fieldName} all operands must match`;
+        case ValueErrorType.Iterator:
+            return `${fieldName} must be an Iterator`;
+        case ValueErrorType.Literal:
+            return `${fieldName} must be ${typeof error.schema.const === 'string' ? `'${error.schema.const}'` : error.schema.const}`;
+        case ValueErrorType.Never:
+            return `${fieldName} is never`;
+        case ValueErrorType.Not:
+            return `${fieldName} must not be ${JSON.stringify(error.schema)}`;
+        case ValueErrorType.Null:
+            return `${fieldName} must be null`;
+        case ValueErrorType.NumberExclusiveMaximum:
+            return `${fieldName} must be less than ${error.schema.exclusiveMaximum}`;
+        case ValueErrorType.NumberExclusiveMinimum:
+            return `${fieldName} must be greater than ${error.schema.exclusiveMinimum}`;
+        case ValueErrorType.NumberMaximum:
+            return `${fieldName} must be less or equal to ${error.schema.maximum}`;
+        case ValueErrorType.NumberMinimum:
+            return `${fieldName} must be greater than or equal to ${error.schema.minimum}`;
+        case ValueErrorType.NumberMultipleOf:
+            return `${fieldName} must be a multiple of ${error.schema.multipleOf}`;
+        case ValueErrorType.Number:
+            return `${fieldName} must be a number`;
+        case ValueErrorType.Object:
+            return `${fieldName} must be an object`;
+        case ValueErrorType.ObjectAdditionalProperties:
+            return `${fieldName} has unexpected property`;
+        case ValueErrorType.ObjectMaxProperties:
+            return `${fieldName} should have no more than ${error.schema.maxProperties} properties`;
+        case ValueErrorType.ObjectMinProperties:
+            return `${fieldName} should have at least ${error.schema.minProperties} properties`;
+        case ValueErrorType.ObjectRequiredProperty:
+            return `${fieldName} must have required property`;
+        case ValueErrorType.Promise:
+            return `${fieldName} must be a Promise`;
+        case ValueErrorType.RegExp:
+            return `${fieldName} must match regular expression`;
+        case ValueErrorType.StringFormatUnknown:
+            return `${fieldName} uses unknown format '${error.schema.format}'`;
+        case ValueErrorType.StringFormat:
+            return `${fieldName} must match match '${error.schema.format}' format`;
+        case ValueErrorType.StringMaxLength:
+            return `${fieldName} length must be less or equal to ${error.schema.maxLength}`;
+        case ValueErrorType.StringMinLength:
+            return `${fieldName} length must be greater or equal to ${error.schema.minLength}`;
+        case ValueErrorType.StringPattern:
+            return `${fieldName} string must match '${error.schema.pattern}'`;
+        case ValueErrorType.String:
+            return `${fieldName} must be a string`;
+        case ValueErrorType.Symbol:
+            return `${fieldName} must be a symbol`;
+        case ValueErrorType.TupleLength:
+            return `${fieldName} must have ${error.schema.maxItems || 0} elements`;
+        case ValueErrorType.Tuple:
+            return `${fieldName} must be a tuple`;
+        case ValueErrorType.Uint8ArrayMaxByteLength:
+            return `${fieldName} byte length less or equal to ${error.schema.maxByteLength}`;
+        case ValueErrorType.Uint8ArrayMinByteLength:
+            return `${fieldName} byte length greater or equal to ${error.schema.minByteLength}`;
+        case ValueErrorType.Uint8Array:
+            return `${fieldName} must be Uint8Array`;
+        case ValueErrorType.Undefined:
+            return `${fieldName} must be undefined`;
+        case ValueErrorType.Union:
+            return `${fieldName} must match one of the union variants`;
+        case ValueErrorType.Void:
+            return `${fieldName} must be void`;
+        case ValueErrorType.Kind:
+            return `Expected kind '${error.schema[Kind]}'`;
+        default:
+            return 'Unknown error type';
+    }
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@loomcore/common",
+  "version": "0.0.1",
+  "private": false,
+  "description": "Loom Core Models- common models, interfaces, types, and utils for Loom Core. All things common to both api and client apps.",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "tsc": "tsc --project tsconfig.prod.json",
+    "build": "npm-run-all -s clean tsc",
+    "add": "git add .",
+    "commit": "git commit -m \"Updates\"",
+    "patch": "npm version patch",
+    "push": "git push",
+    "gar-login": "npx --yes google-artifactregistry-auth",
+    "publishMe": "npm publish",
+    "pub": "npm-run-all -s add commit patch build push publishMe",
+    "auth-and-pub": "npm-run-all -s add commit patch build push gar-login publishMe"
+  },
+  "keywords": [],
+  "author": "Tim Hardy",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./types": "./dist/types/index.js"
+  },
+  "dependencies": {
+    "decimal.js": "^10.5.0"
+  },
+  "peerDependencies": {
+    "@sinclair/typebox": "^0.34.33",
+    "@types/express": "^5.0.1",
+    "express": "^5.1.0"
+  },
+  "devDependencies": {
+    "npm-run-all": "^4.1.5",
+    "typescript": "^5.8.3"
+  }
+}