@roastery/terroir 0.0.1 → 0.0.3

package/dist/index-E6KvVxtW.d.ts

@@ -0,0 +1,55 @@
+import { A as ApplicationException } from './application-exception-mi3iXk8r.js';
+import { InvalidJWTException, UnableToSignPayloadException } from './exceptions/application/jwt/index.js';
+
+declare class ResourceAlreadyExistsException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Resource Already Exists";
+    constructor(source: string, message?: string);
+}
+
+declare class ResourceNotFoundException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Resource Not Found";
+    constructor(source: string, message?: string);
+}
+
+declare class BadRequestException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Bad Request";
+    constructor(source: string, message?: string);
+}
+
+declare class UnauthorizedException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Unauthorized";
+    constructor(source: string, message?: string);
+}
+
+declare class InvalidOperationException extends ApplicationException {
+    source: string;
+    message: string;
+    readonly name = "Invalid Operation";
+    constructor(source: string, message?: string);
+}
+
+type ApplicationExceptions_BadRequestException = BadRequestException;
+declare const ApplicationExceptions_BadRequestException: typeof BadRequestException;
+declare const ApplicationExceptions_InvalidJWTException: typeof InvalidJWTException;
+type ApplicationExceptions_InvalidOperationException = InvalidOperationException;
+declare const ApplicationExceptions_InvalidOperationException: typeof InvalidOperationException;
+type ApplicationExceptions_ResourceAlreadyExistsException = ResourceAlreadyExistsException;
+declare const ApplicationExceptions_ResourceAlreadyExistsException: typeof ResourceAlreadyExistsException;
+type ApplicationExceptions_ResourceNotFoundException = ResourceNotFoundException;
+declare const ApplicationExceptions_ResourceNotFoundException: typeof ResourceNotFoundException;
+declare const ApplicationExceptions_UnableToSignPayloadException: typeof UnableToSignPayloadException;
+type ApplicationExceptions_UnauthorizedException = UnauthorizedException;
+declare const ApplicationExceptions_UnauthorizedException: typeof UnauthorizedException;
+declare namespace ApplicationExceptions {
+  export { ApplicationExceptions_BadRequestException as BadRequestException, ApplicationExceptions_InvalidJWTException as InvalidJWTException, ApplicationExceptions_InvalidOperationException as InvalidOperationException, ApplicationExceptions_ResourceAlreadyExistsException as ResourceAlreadyExistsException, ApplicationExceptions_ResourceNotFoundException as ResourceNotFoundException, ApplicationExceptions_UnableToSignPayloadException as UnableToSignPayloadException, ApplicationExceptions_UnauthorizedException as UnauthorizedException };
+}
+
+export { ApplicationExceptions as A, BadRequestException as B, InvalidOperationException as I, ResourceAlreadyExistsException as R, UnauthorizedException as U, ResourceNotFoundException as a };

package/dist/index-YFuBgYBS.d.cts

@@ -0,0 +1,35 @@
+import { D as DomainException } from './domain-exception-BJknDTC7.cjs';
+
+declare class InvalidDomainDataException extends DomainException {
+    source: string;
+    message: string;
+    readonly name = "Invalid Domain Data";
+    constructor(source: string, message?: string);
+}
+
+declare class OperationFailedException extends DomainException {
+    source: string;
+    message: string;
+    readonly name = "Operation Failed";
+    constructor(source: string, message?: string);
+}
+
+declare class InvalidPropertyException extends DomainException {
+    readonly property: string;
+    readonly source: string;
+    readonly message: string;
+    readonly name = "Invalid Property";
+    constructor(property: string, source: string, message?: string);
+}
+
+type DomainExceptions_InvalidDomainDataException = InvalidDomainDataException;
+declare const DomainExceptions_InvalidDomainDataException: typeof InvalidDomainDataException;
+type DomainExceptions_InvalidPropertyException = InvalidPropertyException;
+declare const DomainExceptions_InvalidPropertyException: typeof InvalidPropertyException;
+type DomainExceptions_OperationFailedException = OperationFailedException;
+declare const DomainExceptions_OperationFailedException: typeof OperationFailedException;
+declare namespace DomainExceptions {
+  export { DomainExceptions_InvalidDomainDataException as InvalidDomainDataException, DomainExceptions_InvalidPropertyException as InvalidPropertyException, DomainExceptions_OperationFailedException as OperationFailedException };
+}
+
+export { DomainExceptions as D, InvalidDomainDataException as I, OperationFailedException as O, InvalidPropertyException as a };

package/dist/index-g4_PChJX.d.cts

@@ -0,0 +1,40 @@
+import { CoreException } from './exceptions/core/index.cjs';
+import { CoreExceptionType } from './exceptions/core/types/index.cjs';
+import { ExceptionLayer } from './exceptions/symbols/index.cjs';
+
+declare class InvalidEntityData extends CoreException {
+    message: string;
+    readonly [ExceptionLayer]: CoreExceptionType;
+    name: string;
+    source: string;
+    constructor(message?: string);
+}
+
+declare class InvalidObjectValueException extends CoreException {
+    objectValueName: string;
+    message: string;
+    readonly [ExceptionLayer]: CoreExceptionType;
+    readonly name = "Invalid Object Value";
+    source: string;
+    constructor(objectValueName: string, message?: string);
+}
+
+declare class UnknownException extends CoreException {
+    message: string;
+    readonly [ExceptionLayer]: CoreExceptionType;
+    name: string;
+    source: string;
+    constructor(message?: string);
+}
+
+type InternalErrors_InvalidEntityData = InvalidEntityData;
+declare const InternalErrors_InvalidEntityData: typeof InvalidEntityData;
+type InternalErrors_InvalidObjectValueException = InvalidObjectValueException;
+declare const InternalErrors_InvalidObjectValueException: typeof InvalidObjectValueException;
+type InternalErrors_UnknownException = UnknownException;
+declare const InternalErrors_UnknownException: typeof UnknownException;
+declare namespace InternalErrors {
+  export { InternalErrors_InvalidEntityData as InvalidEntityData, InternalErrors_InvalidObjectValueException as InvalidObjectValueException, InternalErrors_UnknownException as UnknownException };
+}
+
+export { InternalErrors as I, UnknownException as U, InvalidEntityData as a, InvalidObjectValueException as b };

package/dist/infra-exception-1PUIDeP4.d.ts

@@ -0,0 +1,9 @@
+import { ExceptionLayer } from './exceptions/symbols/index.js';
+import { CoreException } from './exceptions/core/index.js';
+import { CoreExceptionType } from './exceptions/core/types/index.js';
+
+declare abstract class InfraException extends CoreException {
+    readonly [ExceptionLayer]: CoreExceptionType;
+}
+
+export { InfraException as I };

package/dist/infra-exception-Dm1D9yrN.d.cts

@@ -0,0 +1,9 @@
+import { ExceptionLayer } from './exceptions/symbols/index.cjs';
+import { CoreException } from './exceptions/core/index.cjs';
+import { CoreExceptionType } from './exceptions/core/types/index.cjs';
+
+declare abstract class InfraException extends CoreException {
+    readonly [ExceptionLayer]: CoreExceptionType;
+}
+
+export { InfraException as I };

package/dist/schema/formats/index.cjs

@@ -0,0 +1,55 @@
+"use strict";
+
+// src/schema/formats/date-time.ts
+var import_typebox = require("@sinclair/typebox");
+import_typebox.FormatRegistry.Set("date-time", (value) => {
+  return !Number.isNaN(Date.parse(value));
+});
+
+// src/schema/formats/url.ts
+var import_typebox2 = require("@sinclair/typebox");
+import_typebox2.FormatRegistry.Set("url", (value) => {
+  try {
+    const url = new URL(value);
+    return url.hostname.includes(".");
+  } catch {
+    return false;
+  }
+});
+
+// src/schema/formats/uuid.ts
+var import_typebox3 = require("@sinclair/typebox");
+var import_uuid = require("uuid");
+import_typebox3.FormatRegistry.Set("uuid", (value) => (0, import_uuid.validate)(value) && (0, import_uuid.version)(value) === 7);
+
+// src/schema/formats/slug.ts
+var import_typebox4 = require("@sinclair/typebox");
+var slugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+import_typebox4.FormatRegistry.Set("slug", (value) => slugPattern.test(value));
+
+// src/schema/formats/email.ts
+var import_typebox5 = require("@sinclair/typebox");
+var emailPattern = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/i;
+import_typebox5.FormatRegistry.Set("email", (value) => emailPattern.test(value));
+
+// src/schema/formats/json.ts
+var import_typebox6 = require("@sinclair/typebox");
+import_typebox6.FormatRegistry.Set("json", (value) => {
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+});
+
+// src/schema/formats/simple-url.ts
+var import_typebox7 = require("@sinclair/typebox");
+import_typebox7.FormatRegistry.Set("simple-url", (value) => {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+});

package/dist/schema/formats/index.d.cts

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

package/dist/schema/formats/index.d.ts

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

package/dist/schema/formats/index.js

@@ -0,0 +1 @@
+import "../../chunk-YBMFDZEW.js";

package/dist/schema/index.cjs

@@ -0,0 +1,193 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  Schema: () => Schema,
+  SchemaManager: () => SchemaManager
+});
+module.exports = __toCommonJS(schema_exports);
+
+// src/schema/formats/date-time.ts
+var import_typebox = require("@sinclair/typebox");
+import_typebox.FormatRegistry.Set("date-time", (value) => {
+  return !Number.isNaN(Date.parse(value));
+});
+
+// src/schema/formats/url.ts
+var import_typebox2 = require("@sinclair/typebox");
+import_typebox2.FormatRegistry.Set("url", (value) => {
+  try {
+    const url = new URL(value);
+    return url.hostname.includes(".");
+  } catch {
+    return false;
+  }
+});
+
+// src/schema/formats/uuid.ts
+var import_typebox3 = require("@sinclair/typebox");
+var import_uuid = require("uuid");
+import_typebox3.FormatRegistry.Set("uuid", (value) => (0, import_uuid.validate)(value) && (0, import_uuid.version)(value) === 7);
+
+// src/schema/formats/slug.ts
+var import_typebox4 = require("@sinclair/typebox");
+var slugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+import_typebox4.FormatRegistry.Set("slug", (value) => slugPattern.test(value));
+
+// src/schema/formats/email.ts
+var import_typebox5 = require("@sinclair/typebox");
+var emailPattern = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/i;
+import_typebox5.FormatRegistry.Set("email", (value) => emailPattern.test(value));
+
+// src/schema/formats/json.ts
+var import_typebox6 = require("@sinclair/typebox");
+import_typebox6.FormatRegistry.Set("json", (value) => {
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+});
+
+// src/schema/formats/simple-url.ts
+var import_typebox7 = require("@sinclair/typebox");
+import_typebox7.FormatRegistry.Set("simple-url", (value) => {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+});
+
+// src/schema/schema.ts
+var import_value = require("@sinclair/typebox/value");
+var import_compiler = require("@sinclair/typebox/compiler");
+var Schema = class _Schema {
+  constructor(schema) {
+    this.schema = schema;
+    this.compiledSchema = import_compiler.TypeCompiler.Compile(this.schema);
+  }
+  compiledSchema;
+  static make(schema) {
+    return new _Schema(schema);
+  }
+  match(content) {
+    return this.compiledSchema.Check(content);
+  }
+  map(content) {
+    return import_value.Value.Clean(
+      this.schema,
+      import_value.Value.Cast(this.schema, import_value.Value.Convert(this.schema, content))
+    );
+  }
+  toString() {
+    return JSON.stringify(this.schema);
+  }
+  toJSON() {
+    return this.schema;
+  }
+};
+
+// src/schema/schema-manager.ts
+var import_compiler2 = require("@sinclair/typebox/compiler");
+
+// src/schema/utils/hydrate-schema.ts
+var import_type = require("@sinclair/typebox/type");
+function hydrateSchema(schema) {
+  if (typeof schema !== "object" || schema === null) return schema;
+  if (Array.isArray(schema)) return schema.map(hydrateSchema);
+  const newSchema = { ...schema };
+  if (newSchema.properties) {
+    for (const key in newSchema.properties) {
+      newSchema.properties[key] = hydrateSchema(newSchema.properties[key]);
+    }
+  }
+  if (newSchema.items) {
+    newSchema.items = hydrateSchema(newSchema.items);
+  }
+  if (newSchema.additionalProperties && typeof newSchema.additionalProperties === "object") {
+    newSchema.additionalProperties = hydrateSchema(
+      newSchema.additionalProperties
+    );
+  }
+  if (newSchema.anyOf) newSchema.anyOf = newSchema.anyOf.map(hydrateSchema);
+  if (newSchema.allOf) newSchema.allOf = newSchema.allOf.map(hydrateSchema);
+  if (newSchema.oneOf) newSchema.oneOf = newSchema.oneOf.map(hydrateSchema);
+  if (newSchema.not) newSchema.not = hydrateSchema(newSchema.not);
+  if (newSchema.type === "string") newSchema[import_type.Kind] = "String";
+  else if (newSchema.type === "number") newSchema[import_type.Kind] = "Number";
+  else if (newSchema.type === "integer") newSchema[import_type.Kind] = "Integer";
+  else if (newSchema.type === "boolean") newSchema[import_type.Kind] = "Boolean";
+  else if (newSchema.type === "array") newSchema[import_type.Kind] = "Array";
+  else if (newSchema.type === "object") newSchema[import_type.Kind] = "Object";
+  else if (newSchema.type === "null") newSchema[import_type.Kind] = "Null";
+  if (newSchema.anyOf) newSchema[import_type.Kind] = "Union";
+  if (newSchema.allOf) newSchema[import_type.Kind] = "Intersect";
+  if (newSchema.not) newSchema[import_type.Kind] = "Not";
+  if (newSchema.const !== void 0) newSchema[import_type.Kind] = "Literal";
+  if (newSchema.type === "array" && Array.isArray(newSchema.items)) {
+    newSchema[import_type.Kind] = "Tuple";
+  }
+  if (newSchema.type === "object" && newSchema.patternProperties && !newSchema.properties) {
+    newSchema[import_type.Kind] = "Record";
+    for (const key in newSchema.patternProperties) {
+      newSchema.patternProperties[key] = hydrateSchema(
+        newSchema.patternProperties[key]
+      );
+    }
+  } else if (newSchema.patternProperties) {
+    for (const key in newSchema.patternProperties) {
+      newSchema.patternProperties[key] = hydrateSchema(
+        newSchema.patternProperties[key]
+      );
+    }
+  }
+  if (Object.keys(newSchema).length === 0) {
+    newSchema[import_type.Kind] = "Any";
+  }
+  return newSchema;
+}
+
+// src/schema/schema-manager.ts
+var SchemaManager = {
+  build(schema) {
+    const parsedSchema = JSON.parse(schema);
+    const hydrated = hydrateSchema(parsedSchema);
+    return new Schema(hydrated);
+  },
+  isSchema(schema) {
+    try {
+      if (typeof schema === "string") schema = JSON.parse(schema);
+      const hydrated = hydrateSchema(schema);
+      import_compiler2.TypeCompiler.Compile(hydrated);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Schema,
+  SchemaManager
+});

package/dist/schema/index.d.cts

@@ -0,0 +1,19 @@
+import { TSchema, Static } from '@sinclair/typebox';
+
+declare class Schema<SchemaType extends TSchema> {
+    private schema;
+    private compiledSchema;
+    constructor(schema: SchemaType);
+    static make<SchemaType extends TSchema>(schema: SchemaType): Schema<SchemaType>;
+    match(content: unknown): boolean;
+    map(content: unknown): Static<SchemaType>;
+    toString(): string;
+    toJSON(): typeof this.schema;
+}
+
+declare const SchemaManager: {
+    build<SchemaType extends TSchema>(schema: string): Schema<SchemaType>;
+    isSchema(schema: unknown): boolean;
+};
+
+export { Schema, SchemaManager };

package/dist/schema/index.d.ts

@@ -0,0 +1,19 @@
+import { TSchema, Static } from '@sinclair/typebox';
+
+declare class Schema<SchemaType extends TSchema> {
+    private schema;
+    private compiledSchema;
+    constructor(schema: SchemaType);
+    static make<SchemaType extends TSchema>(schema: SchemaType): Schema<SchemaType>;
+    match(content: unknown): boolean;
+    map(content: unknown): Static<SchemaType>;
+    toString(): string;
+    toJSON(): typeof this.schema;
+}
+
+declare const SchemaManager: {
+    build<SchemaType extends TSchema>(schema: string): Schema<SchemaType>;
+    isSchema(schema: unknown): boolean;
+};
+
+export { Schema, SchemaManager };

package/dist/schema/index.js

@@ -0,0 +1,113 @@
+import "../chunk-YBMFDZEW.js";
+
+// src/schema/schema.ts
+import { Value } from "@sinclair/typebox/value";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+var Schema = class _Schema {
+  constructor(schema) {
+    this.schema = schema;
+    this.compiledSchema = TypeCompiler.Compile(this.schema);
+  }
+  compiledSchema;
+  static make(schema) {
+    return new _Schema(schema);
+  }
+  match(content) {
+    return this.compiledSchema.Check(content);
+  }
+  map(content) {
+    return Value.Clean(
+      this.schema,
+      Value.Cast(this.schema, Value.Convert(this.schema, content))
+    );
+  }
+  toString() {
+    return JSON.stringify(this.schema);
+  }
+  toJSON() {
+    return this.schema;
+  }
+};
+
+// src/schema/schema-manager.ts
+import { TypeCompiler as TypeCompiler2 } from "@sinclair/typebox/compiler";
+
+// src/schema/utils/hydrate-schema.ts
+import { Kind } from "@sinclair/typebox/type";
+function hydrateSchema(schema) {
+  if (typeof schema !== "object" || schema === null) return schema;
+  if (Array.isArray(schema)) return schema.map(hydrateSchema);
+  const newSchema = { ...schema };
+  if (newSchema.properties) {
+    for (const key in newSchema.properties) {
+      newSchema.properties[key] = hydrateSchema(newSchema.properties[key]);
+    }
+  }
+  if (newSchema.items) {
+    newSchema.items = hydrateSchema(newSchema.items);
+  }
+  if (newSchema.additionalProperties && typeof newSchema.additionalProperties === "object") {
+    newSchema.additionalProperties = hydrateSchema(
+      newSchema.additionalProperties
+    );
+  }
+  if (newSchema.anyOf) newSchema.anyOf = newSchema.anyOf.map(hydrateSchema);
+  if (newSchema.allOf) newSchema.allOf = newSchema.allOf.map(hydrateSchema);
+  if (newSchema.oneOf) newSchema.oneOf = newSchema.oneOf.map(hydrateSchema);
+  if (newSchema.not) newSchema.not = hydrateSchema(newSchema.not);
+  if (newSchema.type === "string") newSchema[Kind] = "String";
+  else if (newSchema.type === "number") newSchema[Kind] = "Number";
+  else if (newSchema.type === "integer") newSchema[Kind] = "Integer";
+  else if (newSchema.type === "boolean") newSchema[Kind] = "Boolean";
+  else if (newSchema.type === "array") newSchema[Kind] = "Array";
+  else if (newSchema.type === "object") newSchema[Kind] = "Object";
+  else if (newSchema.type === "null") newSchema[Kind] = "Null";
+  if (newSchema.anyOf) newSchema[Kind] = "Union";
+  if (newSchema.allOf) newSchema[Kind] = "Intersect";
+  if (newSchema.not) newSchema[Kind] = "Not";
+  if (newSchema.const !== void 0) newSchema[Kind] = "Literal";
+  if (newSchema.type === "array" && Array.isArray(newSchema.items)) {
+    newSchema[Kind] = "Tuple";
+  }
+  if (newSchema.type === "object" && newSchema.patternProperties && !newSchema.properties) {
+    newSchema[Kind] = "Record";
+    for (const key in newSchema.patternProperties) {
+      newSchema.patternProperties[key] = hydrateSchema(
+        newSchema.patternProperties[key]
+      );
+    }
+  } else if (newSchema.patternProperties) {
+    for (const key in newSchema.patternProperties) {
+      newSchema.patternProperties[key] = hydrateSchema(
+        newSchema.patternProperties[key]
+      );
+    }
+  }
+  if (Object.keys(newSchema).length === 0) {
+    newSchema[Kind] = "Any";
+  }
+  return newSchema;
+}
+
+// src/schema/schema-manager.ts
+var SchemaManager = {
+  build(schema) {
+    const parsedSchema = JSON.parse(schema);
+    const hydrated = hydrateSchema(parsedSchema);
+    return new Schema(hydrated);
+  },
+  isSchema(schema) {
+    try {
+      if (typeof schema === "string") schema = JSON.parse(schema);
+      const hydrated = hydrateSchema(schema);
+      TypeCompiler2.Compile(hydrated);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+};
+export {
+  Schema,
+  SchemaManager
+};