@palmares/schemas 0.0.1 → 0.1.0

package/__tests__/drizzle.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './.drizzle/schema.ts',
+  out: './.drizzle/migrations',
+  dialect: 'sqlite',
+  dbCredentials: {
+    databaseId: 'default',
+    url: 'sqlite.db',
+  },
+});

package/__tests__/eslint.config.js

@@ -0,0 +1,10 @@
+import config from '../../../eslint.config.js';
+
+/** @type {import('eslint').Linter.RulesRecord} */
+const configs = [{
+  ...config[0],
+  name: '@palmares/databases/tests',
+  files: ['src/**/*.ts', 'src/**/*.postgres.ts', 'manage.ts', 'drizzle.config.ts', '.drizzle/schema.ts'],
+}];
+
+export default configs;

package/__tests__/manage.ts

@@ -0,0 +1,5 @@
+import { Commands } from '@palmares/core';
+
+import settings from './src/settings';
+
+Commands.handleCommands(settings, process.argv.slice(2));

package/__tests__/node_modules/.bin/drizzle-kit

@@ -0,0 +1,17 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/drizzle-kit@0.23.0/node_modules/drizzle-kit/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/drizzle-kit@0.23.0/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/drizzle-kit@0.23.0/node_modules/drizzle-kit/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/drizzle-kit@0.23.0/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../drizzle-kit/bin.cjs" "$@"
+else
+  exec node  "$basedir/../drizzle-kit/bin.cjs" "$@"
+fi

package/__tests__/node_modules/.bin/esbuild

@@ -0,0 +1,14 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/esbuild@0.19.12/node_modules/esbuild/bin/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/esbuild@0.19.12/node_modules/esbuild/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/esbuild@0.19.12/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/esbuild@0.19.12/node_modules/esbuild/bin/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/esbuild@0.19.12/node_modules/esbuild/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/esbuild@0.19.12/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+"$basedir/../../../../../node_modules/.pnpm/esbuild@0.19.12/node_modules/esbuild/bin/esbuild"   "$@"
+exit $?

package/__tests__/node_modules/.bin/tsc

@@ -0,0 +1,17 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules/typescript/bin/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules/typescript/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules/typescript/bin/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules/typescript/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsc" "$@"
+fi

package/__tests__/node_modules/.bin/tsserver

@@ -0,0 +1,17 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules/typescript/bin/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules/typescript/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules/typescript/bin/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules/typescript/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/typescript@5.5.4/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsserver" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsserver" "$@"
+fi

package/__tests__/node_modules/.bin/tsx

@@ -0,0 +1,17 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/tsx@4.16.2/node_modules/tsx/dist/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/tsx@4.16.2/node_modules/tsx/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/tsx@4.16.2/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/tsx@4.16.2/node_modules/tsx/dist/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/tsx@4.16.2/node_modules/tsx/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/tsx@4.16.2/node_modules:/Users/nicolasmelo/workspace/palmares/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../tsx/dist/cli.mjs" "$@"
+else
+  exec node  "$basedir/../tsx/dist/cli.mjs" "$@"
+fi

package/__tests__/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@tests/schemas",
+  "version": "0.0.1",
+  "description": "testing the schemas",
+  "main": "manage.ts",
+  "scripts": {
+    "test": "tsx manage.ts test",
+    "test:watch": "WATCH=true tsx manage.ts test",
+    "load": "tsx manage.ts load-models",
+    "makemigrations": "drizzle-kit generate",
+    "migrate": "tsx manage.ts drizzleMigrate"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@palmares/console-logging": "workspace:*",
+    "@palmares/core": "workspace:*",
+    "@palmares/databases": "workspace:*",
+    "@palmares/drizzle-engine": "workspace:*",
+    "@palmares/jest-tests": "workspace:*",
+    "@palmares/logging": "workspace:*",
+    "@palmares/node-std": "workspace:*",
+    "@palmares/schemas": "workspace:*",
+    "@palmares/tests": "workspace:*",
+    "@palmares/zod-schema": "workspace:*",
+    "better-sqlite3": "^11.1.2",
+    "drizzle-kit": "^0.23.0",
+    "drizzle-orm": "^0.32.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "tsx": "^4.16.2",
+    "typescript": "^5.5.4"
+  }
+}

package/__tests__/src/core/array.test.ts

@@ -0,0 +1,130 @@
+import * as p from '@palmares/schemas';
+import { describe } from '@palmares/tests';
+
+import type JestTestAdapter from '@palmares/jest-tests';
+
+describe<JestTestAdapter>('Array Tests', ({ test }) => {
+  test('optional', async ({ expect }) => {
+    const arraySchema = p.array([p.number()]);
+    const tupleSchema = p.array(p.number(), p.string());
+    const arraySchemaWithCustomMessage = p.array([p.number()]).nonOptional({ message: 'hello' });
+    const tupleSchemaWithCustomMessage = p.array(p.number(), p.string()).nonOptional({ message: 'hello' });
+
+    const [
+      { errors: errorsArrayOnFail },
+      { errors: errorsTupleOnFail },
+      { errors: errorsArrayOnFailWithCustomMessage },
+      { errors: errorsTupleOnFailWithCustomMessage },
+      { errors: errorsOnValidArray, parsed: parsedArray },
+      { errors: errorsOnValidTuple, parsed: parsedTuple }
+    ] = await Promise.all([
+      arraySchema.parse(undefined as any),
+      tupleSchema.parse(undefined as any),
+      arraySchemaWithCustomMessage.parse(undefined as any),
+      tupleSchemaWithCustomMessage.parse(undefined as any),
+      arraySchema.parse([1, 2, 3]),
+      tupleSchema.parse([1, 'test'])
+    ]);
+
+    expect(errorsArrayOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsTupleOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsArrayOnFail?.[0]?.code).toBe('required');
+    expect(errorsArrayOnFail?.[0]?.message).toBe('Required');
+    expect(errorsTupleOnFail?.[0]?.code).toBe('required');
+    expect(errorsTupleOnFail?.[0]?.message).toBe('Required');
+    expect((errorsOnValidArray || []).length).toBe(0);
+    expect(parsedArray[0]).toBe(1);
+    expect(parsedArray[2]).toBe(3);
+    expect((errorsOnValidTuple || []).length).toBe(0);
+    expect(parsedTuple[0]).toBe(1);
+    expect(parsedTuple[1]).toBe('test');
+  });
+
+  test('nullable', async ({ expect }) => {
+    const arraySchema = p.array([p.number()]);
+    const tupleSchema = p.array(p.number(), p.string());
+    const arraySchemaWithCustomMessage = p.array([p.number()]).nonNullable({ message: 'hello' });
+    const tupleSchemaWithCustomMessage = p.array(p.number(), p.string()).nonNullable({ message: 'hello' });
+
+    const [
+      { errors: errorsArrayOnFail },
+      { errors: errorsTupleOnFail },
+      { errors: errorsArrayOnFailWithCustomMessage },
+      { errors: errorsTupleOnFailWithCustomMessage },
+      { errors: errorsOnValidArray, parsed: parsedArray },
+      { errors: errorsOnValidTuple, parsed: parsedTuple }
+    ] = await Promise.all([
+      arraySchema.parse(null as any),
+      tupleSchema.parse(null as any),
+      arraySchemaWithCustomMessage.parse(null as any),
+      tupleSchemaWithCustomMessage.parse(null as any),
+      arraySchema.parse([1, 2, 3]),
+      tupleSchema.parse([1, 'test'])
+    ]);
+
+    expect(errorsArrayOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsTupleOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsArrayOnFail?.[0]?.code).toBe('null');
+    expect(errorsArrayOnFail?.[0]?.message).toBe('Cannot be null');
+    expect(errorsTupleOnFail?.[0]?.code).toBe('null');
+    expect(errorsTupleOnFail?.[0]?.message).toBe('Cannot be null');
+    expect((errorsOnValidArray || []).length).toBe(0);
+    expect(parsedArray[0]).toBe(1);
+    expect(parsedArray[2]).toBe(3);
+    expect((errorsOnValidTuple || []).length).toBe(0);
+    expect(parsedTuple[0]).toBe(1);
+    expect(parsedTuple[1]).toBe('test');
+  });
+
+  test('nested', async ({ expect }) => {
+    const arraySchema = p.array([p.union([p.number(), p.string().toRepresentation(async () => 'hey')])]);
+
+    const data = await arraySchema.data(['test', 1]);
+
+    expect(data[0]).toBe('hey');
+    expect(data[1]).toBe(1)
+  });
+
+  test('min length', async ({ expect }) => {
+    const arraySchema = p.array([p.number()]).minLength(1);
+    const arraySchemaWithCustomMessage = p.array([p.number()]).minLength(1, { inclusive: true, message: 'hello' });
+
+    const [
+      { errors: errorsArrayOnFail },
+      { errors: errorsArrayOnFailWithCustomMessage },
+      { errors: errorsOnValidArray, parsed: parsedArray }
+    ] = await Promise.all([
+      arraySchema.parse([] as any),
+      arraySchemaWithCustomMessage.parse([] as any),
+      arraySchema.parse([1, 2, 3])
+    ]);
+
+    expect(errorsArrayOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsArrayOnFail?.[0]?.code).toBe('minLength');
+    expect(errorsArrayOnFail?.[0]?.message).toBe('The array must have a minimum length of 1');
+    expect((errorsOnValidArray || []).length).toBe(0);
+    expect(parsedArray[0]).toBe(1);
+    expect(parsedArray[2]).toBe(3);
+  });
+
+  test('max length', async ({ expect }) => {
+    const arraySchema = p.array([p.number()]).maxLength(1);
+    const arraySchemaWithCustomMessage = p.array([p.number()]).maxLength(1, { inclusive: true, message: 'hello' });
+
+    const [
+      { errors: errorsArrayOnFail },
+      { errors: errorsArrayOnFailWithCustomMessage },
+      { errors: errorsOnValidArray, parsed: parsedArray }
+    ] = await Promise.all([
+      arraySchema.parse([1, 2, 3] as any),
+      arraySchemaWithCustomMessage.parse([1, 2, 3] as any),
+      arraySchema.parse([1])
+    ]);
+
+    expect(errorsArrayOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsArrayOnFail?.[0]?.code).toBe('maxLength');
+    expect(errorsArrayOnFail?.[0]?.message).toBe('The array must have a maximum length of 1');
+    expect((errorsOnValidArray || []).length).toBe(0);
+    expect(parsedArray[0]).toBe(1);
+  });
+});

package/__tests__/src/core/boolean.test.ts

@@ -0,0 +1,66 @@
+import * as p from '@palmares/schemas';
+import { describe } from '@palmares/tests';
+
+import type JestTestAdapter from '@palmares/jest-tests';
+
+describe<JestTestAdapter>('Boolean Tests', ({ test }) => {
+  test('optional', async ({ expect }) => {
+    const booleanSchema = p.boolean();
+    const booleanSchemaWithCustomMessage = p.boolean().nonOptional({ message: 'hello' });
+
+    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
+      await Promise.all([
+        booleanSchema.parse(undefined as any),
+        booleanSchemaWithCustomMessage.parse(undefined as any),
+        booleanSchema.parse(true)
+      ]);
+
+    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsOnFail?.[0]?.code).toBe('required');
+    expect(errorsOnFail?.[0]?.message).toBe('Required');
+    expect((errorsOnValid || []).length).toBe(0);
+    expect(parsed).toBe(true);
+  });
+
+  test('nullable', async ({ expect }) => {
+    const booleanSchema = p.boolean();
+    const booleanSchemaWithCustomMessage = p.boolean().nonNullable({ message: 'hello' });
+
+    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
+      await Promise.all([
+        booleanSchema.parse(null as any),
+        booleanSchemaWithCustomMessage.parse(null as any),
+        booleanSchema.parse(true)
+      ]);
+
+    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsOnFail?.[0]?.code).toBe('null');
+    expect(errorsOnFail?.[0]?.message).toBe('Cannot be null');
+    expect((errorsOnValid || []).length).toBe(0);
+    expect(parsed).toBe(true);
+  });
+
+  test('true and false values', async ({ expect }) => {
+    const booleanSchema = p.boolean().trueValues(['Y']).falseValues(['N']);
+
+    const [{ errors: errorsTrue, parsed: parsedTrue }, { errors: errorsFalse, parsed: parsedFalse }] =
+      await Promise.all([booleanSchema.parse('Y'), booleanSchema.parse('N')]);
+
+    expect((errorsTrue || []).length).toBe(0);
+    expect((errorsFalse || []).length).toBe(0);
+    expect(parsedTrue).toBe(true);
+    expect(parsedFalse).toBe(false);
+  });
+
+  test('number and string values', async ({ expect }) => {
+    const booleanSchema = p.boolean().allowNumber().allowString();
+
+    const [{ errors: errorsNumber, parsed: parsedNumber }, { errors: errorsString, parsed: parsedString }] =
+      await Promise.all([booleanSchema.parse(1), booleanSchema.parse('true')]);
+
+    expect((errorsNumber || []).length).toBe(0);
+    expect((errorsString || []).length).toBe(0);
+    expect(parsedNumber).toBe(true);
+    expect(parsedString).toBe(true);
+  });
+});

package/__tests__/src/core/datetime.test.ts

@@ -0,0 +1,102 @@
+import * as p from '@palmares/schemas';
+import { describe } from '@palmares/tests';
+
+import type JestTestAdapter from '@palmares/jest-tests';
+
+describe<JestTestAdapter>('Datetime Tests', ({ test }) => {
+  test('optional', async ({ expect }) => {
+    const datetimeSchema = p.datetime();
+    const datetimeSchemaWithCustomMessage = p.datetime().nonOptional({ message: 'hello' });
+    const now = new Date();
+
+    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
+      await Promise.all([
+        datetimeSchema.parse(undefined as any),
+        datetimeSchemaWithCustomMessage.parse(undefined as any),
+        datetimeSchema.parse(now)
+      ]);
+
+    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsOnFail?.[0]?.code).toBe('required');
+    expect(errorsOnFail?.[0]?.message).toBe('Required');
+    expect((errorsOnValid || []).length).toBe(0);
+    expect(parsed.toISOString()).toBe(now.toISOString());
+  });
+
+  test('nullable', async ({ expect }) => {
+    const datetimeSchema = p.datetime();
+    const datetimeSchemaWithCustomMessage = p.datetime().nonNullable({ message: 'hello' });
+    const now = new Date();
+
+    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
+      await Promise.all([
+        datetimeSchema.parse(null as any),
+        datetimeSchemaWithCustomMessage.parse(null as any),
+        datetimeSchema.parse(now)
+      ]);
+
+    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsOnFail?.[0]?.code).toBe('null');
+    expect(errorsOnFail?.[0]?.message).toBe('Cannot be null');
+    expect((errorsOnValid || []).length).toBe(0);
+    expect(parsed.toISOString()).toBe(now.toISOString());
+  });
+
+  test('below', async ({ expect }) => {
+    const nowMinus10Minutes = new Date();
+    nowMinus10Minutes.setMinutes(-10);
+    const nowMinus20Minutes = new Date();
+    nowMinus20Minutes.setMinutes(-20);
+    const datetimeSchema = p.datetime().below(nowMinus10Minutes);
+    const datetimeSchemaWithCustomMessage = p
+      .datetime()
+      .below(nowMinus10Minutes, { message: 'hello', inclusive: false });
+
+    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
+      await Promise.all([
+        datetimeSchema.parse(nowMinus10Minutes),
+        datetimeSchemaWithCustomMessage.parse(nowMinus10Minutes),
+        datetimeSchema.parse(nowMinus20Minutes)
+      ]);
+
+    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsOnFail?.[0]?.code).toBe('below');
+    expect(errorsOnFail?.[0]?.message).toBe('Value is not below the specified date');
+    expect((errorsOnValid || []).length).toBe(0);
+    expect(parsed.toISOString()).toBe(nowMinus20Minutes.toISOString());
+  });
+
+  test('above', async ({ expect }) => {
+    const nowPlus10Minutes = new Date();
+    nowPlus10Minutes.setMinutes(nowPlus10Minutes.getMinutes() + 10);
+    const nowPlus20Minutes = new Date();
+    nowPlus20Minutes.setMinutes(nowPlus20Minutes.getMinutes() + 20);
+    const datetimeSchema = p.datetime().above(nowPlus10Minutes);
+    const datetimeSchemaWithCustomMessage = p
+      .datetime()
+      .below(nowPlus10Minutes, { message: 'hello', inclusive: false });
+
+    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
+      await Promise.all([
+        datetimeSchema.parse(nowPlus10Minutes),
+        datetimeSchemaWithCustomMessage.parse(nowPlus10Minutes),
+        datetimeSchema.parse(nowPlus20Minutes)
+      ]);
+
+    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
+    expect(errorsOnFail?.[0]?.code).toBe('above');
+    expect(errorsOnFail?.[0]?.message).toBe('Value is not above the specified date');
+    expect((errorsOnValid || []).length).toBe(0);
+    expect(parsed.toISOString()).toBe(nowPlus20Minutes.toISOString());
+  });
+
+  test('allowString', async ({ expect }) => {
+    const datetimeSchema = p.datetime().allowString();
+    const now = new Date();
+
+    const { errors: errorsOnValid, parsed } = await datetimeSchema.parse(now.toISOString());
+
+    expect((errorsOnValid || []).length).toBe(0);
+    expect((parsed as Date).toISOString()).toBe(now.toISOString());
+  });
+});

package/__tests__/src/core/index.ts

@@ -0,0 +1,35 @@
+import { domain } from '@palmares/core';
+import { testDomainModifier, } from '@palmares/tests';
+import { databaseDomainModifier } from '@palmares/databases';
+import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
+
+import * as models from './models';
+import { db } from '../settings';
+
+export default domain('testingDrizzle', __dirname, {
+  commands: {
+    drizzleMigrate: {
+      description: 'Migrate the database using drizzle',
+      keywordArgs: undefined,
+      positionalArgs: undefined,
+      handler: () => {
+        migrate(db, { migrationsFolder: './.drizzle/migrations' });
+      }
+    }
+  },
+  modifiers: [testDomainModifier, databaseDomainModifier] as const,
+  getMigrations: () => [],
+  getModels: () => models,
+  getTests: () => [
+    __dirname + '/test.test.ts',
+    __dirname + '/numbers.test.ts',
+    __dirname + '/boolean.test.ts',
+    __dirname + '/datetime.test.ts',
+    __dirname + '/object.test.ts',
+    __dirname + '/union.test.ts',
+    __dirname + '/array.test.ts',
+    __dirname + '/types.test.ts',
+    __dirname + '/string.test.ts',
+    __dirname + '/model.test.ts'
+  ]
+});