@roastery/terroir 0.0.1 → 0.0.2

package/dist/schema/index.cjs

@@ -0,0 +1,195 @@
+"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,115 @@
+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
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@roastery/terroir",
-    "version": "0.0.1",
+    "version": "0.0.2",
     "type": "module",
     "author": {
         "name": "Alan Reis",
@@ -34,26 +34,25 @@
     ],
     "scripts": {
         "build": "tsup 'src/**/index.ts' --format cjs,esm --dts --tsconfig tsconfig.build.json --clean",
-        "test:unit": "vitest run",
-        "test:ui": "vitest --ui",
-        "test:coverage": "vitest run --coverage",
+        "test:unit": "bun test --env-file=.env.testing",
+        "test:coverage": "bun test --env-file=.env.testing --coverage",
         "setup": "bun run build && bun link",
         "prepare": "husky || true"
     },
     "devDependencies": {
         "@faker-js/faker": "^10.2.0",
-        "@types/bun": "latest",
         "@vitest/coverage-v8": "^4.0.18",
         "@vitest/ui": "^4.0.18",
         "tsup": "^8.5.1",
-        "vite-tsconfig-paths": "^6.0.5",
-        "vitest": "^4.0.18",
         "@commitlint/cli": "^20.4.1",
         "@commitlint/config-conventional": "^20.4.1",
         "husky": "^9.1.7"
     },
     "peerDependencies": {
-        "typescript": "^5"
+        "typescript": "^5",
+        "@sinclair/typebox": ">= 0.34.0 < 1",
+        "@types/bun": "latest",
+        "uuid": "^13.0.0"
     },
     "dependencies": {}
 }

package/dist/index.d.cts

@@ -1,3 +0,0 @@
-declare const hello = "world";
-
-export { hello };

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-declare const hello = "world";
-
-export { hello };

package/dist/index.js

@@ -1,5 +0,0 @@
-// src/hello.ts
-var hello = "world";
-export {
-  hello
-};