@c15t/backend 1.8.0 → 2.0.0-rc.1

package/dist/pkgs/data-model/fields/index.cjs

@@ -1,159 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    generateId: ()=>generateId,
-    validateField: ()=>validateField,
-    COMMON_TIMEZONES: ()=>COMMON_TIMEZONES,
-    getDatabaseType: ()=>getDatabaseType
-});
-const COMMON_TIMEZONES = {
-    UTC: 'UTC',
-    GMT: 'GMT',
-    EASTERN: 'America/New_York',
-    CENTRAL: 'America/Chicago',
-    MOUNTAIN: 'America/Denver',
-    PACIFIC: 'America/Los_Angeles',
-    LONDON: 'Europe/London',
-    PARIS: 'Europe/Paris',
-    BERLIN: 'Europe/Berlin',
-    TOKYO: 'Asia/Tokyo',
-    SHANGHAI: 'Asia/Shanghai',
-    SINGAPORE: 'Asia/Singapore',
-    SYDNEY: 'Australia/Sydney',
-    SAO_PAULO: 'America/Sao_Paulo'
-};
-const external_base_x_namespaceObject = require("base-x");
-var external_base_x_default = /*#__PURE__*/ __webpack_require__.n(external_base_x_namespaceObject);
-const b58 = external_base_x_default()('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
-function generateId(prefix) {
-    const buf = crypto.getRandomValues(new Uint8Array(20));
-    const EPOCH_TIMESTAMP = 1700000000000;
-    const t = Date.now() - EPOCH_TIMESTAMP;
-    const high = Math.floor(t / 0x100000000);
-    const low = t >>> 0;
-    buf[0] = high >>> 24 & 255;
-    buf[1] = high >>> 16 & 255;
-    buf[2] = high >>> 8 & 255;
-    buf[3] = 255 & high;
-    buf[4] = low >>> 24 & 255;
-    buf[5] = low >>> 16 & 255;
-    buf[6] = low >>> 8 & 255;
-    buf[7] = 255 & low;
-    return `${prefix}_${b58.encode(buf)}`;
-}
-const currentDatabaseType = 'unknown';
-function getDatabaseType() {
-    return currentDatabaseType;
-}
-const external_zod_namespaceObject = require("zod");
-const fieldConfigSchema = external_zod_namespaceObject.z.object({
-    required: external_zod_namespaceObject.z.boolean().prefault(true),
-    returned: external_zod_namespaceObject.z.boolean().prefault(true),
-    input: external_zod_namespaceObject.z.boolean().prefault(true),
-    defaultValue: external_zod_namespaceObject.z.any().optional(),
-    transform: external_zod_namespaceObject.z.object({
-        input: external_zod_namespaceObject.z.any().optional(),
-        output: external_zod_namespaceObject.z.any().optional()
-    }).optional(),
-    validator: external_zod_namespaceObject.z.any().optional(),
-    unique: external_zod_namespaceObject.z.boolean().optional(),
-    indexed: external_zod_namespaceObject.z.boolean().optional(),
-    sortable: external_zod_namespaceObject.z.boolean().prefault(true),
-    fieldName: external_zod_namespaceObject.z.string().optional(),
-    bigint: external_zod_namespaceObject.z.boolean().prefault(false)
-});
-const stringFieldSchema = fieldConfigSchema.extend({
-    type: external_zod_namespaceObject.z.literal('string'),
-    minLength: external_zod_namespaceObject.z.number().optional(),
-    maxLength: external_zod_namespaceObject.z.number().optional(),
-    pattern: external_zod_namespaceObject.z.string().optional()
-});
-const numberFieldSchema = fieldConfigSchema.extend({
-    type: external_zod_namespaceObject.z.literal('number'),
-    min: external_zod_namespaceObject.z.number().optional(),
-    max: external_zod_namespaceObject.z.number().optional()
-});
-const booleanFieldSchema = fieldConfigSchema.extend({
-    type: external_zod_namespaceObject.z.literal('boolean')
-});
-const dateFieldSchema = fieldConfigSchema.extend({
-    type: external_zod_namespaceObject.z.literal('date'),
-    minDate: external_zod_namespaceObject.z.date().optional(),
-    maxDate: external_zod_namespaceObject.z.date().optional(),
-    dateOnly: external_zod_namespaceObject.z.boolean().prefault(false),
-    format: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional()
-});
-const timezoneFieldSchema = fieldConfigSchema.extend({
-    type: external_zod_namespaceObject.z.literal('timezone'),
-    validateTimezone: external_zod_namespaceObject.z.boolean().prefault(true),
-    suggestedValues: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
-    restrictToSuggestedValues: external_zod_namespaceObject.z.boolean().prefault(false)
-});
-const jsonFieldSchema = fieldConfigSchema.extend({
-    type: external_zod_namespaceObject.z.literal('json'),
-    validateJson: external_zod_namespaceObject.z.boolean().prefault(true)
-});
-const stringArrayFieldSchema = fieldConfigSchema.extend({
-    type: external_zod_namespaceObject.z.literal('string[]')
-});
-const numberArrayFieldSchema = fieldConfigSchema.extend({
-    type: external_zod_namespaceObject.z.literal('number[]')
-});
-const fieldSchema = external_zod_namespaceObject.z.discriminatedUnion('type', [
-    stringFieldSchema,
-    numberFieldSchema,
-    booleanFieldSchema,
-    dateFieldSchema,
-    timezoneFieldSchema,
-    jsonFieldSchema,
-    stringArrayFieldSchema,
-    numberArrayFieldSchema
-]);
-function validateField(field) {
-    return fieldSchema.parse(field);
-}
-exports.COMMON_TIMEZONES = __webpack_exports__.COMMON_TIMEZONES;
-exports.generateId = __webpack_exports__.generateId;
-exports.getDatabaseType = __webpack_exports__.getDatabaseType;
-exports.validateField = __webpack_exports__.validateField;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "COMMON_TIMEZONES",
-    "generateId",
-    "getDatabaseType",
-    "validateField"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/pkgs/data-model/fields/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Fields Module
- *
- * This module provides field definition utilities for the data model system.
- */
-export type { DateFieldOptions, NumberFieldOptions, StringFieldOptions, } from './field-factory';
-export { COMMON_TIMEZONES } from './field-factory';
-export type { InferFieldInput, InferFieldOutput, } from './field-inference';
-export type { Field, FieldConfig, FieldType, JsonValue, Primitive, } from './field-types';
-export { generateId } from './id-generator';
-export { type DatabaseType, getDatabaseType, } from './superjson-utils';
-export { validateField } from './zod-fields';
-//# sourceMappingURL=index.d.ts.map

package/dist/pkgs/data-model/fields/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/data-model/fields/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACX,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GAClB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,YAAY,EACX,eAAe,EACf,gBAAgB,GAChB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACX,KAAK,EACL,WAAW,EACX,SAAS,EACT,SAAS,EACT,SAAS,GACT,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5C,OAAO,EACN,KAAK,YAAY,EACjB,eAAe,GACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/pkgs/data-model/fields/index.js

@@ -1,106 +0,0 @@
-import base_x from "base-x";
-import { z } from "zod";
-const COMMON_TIMEZONES = {
-    UTC: 'UTC',
-    GMT: 'GMT',
-    EASTERN: 'America/New_York',
-    CENTRAL: 'America/Chicago',
-    MOUNTAIN: 'America/Denver',
-    PACIFIC: 'America/Los_Angeles',
-    LONDON: 'Europe/London',
-    PARIS: 'Europe/Paris',
-    BERLIN: 'Europe/Berlin',
-    TOKYO: 'Asia/Tokyo',
-    SHANGHAI: 'Asia/Shanghai',
-    SINGAPORE: 'Asia/Singapore',
-    SYDNEY: 'Australia/Sydney',
-    SAO_PAULO: 'America/Sao_Paulo'
-};
-const b58 = base_x('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
-function generateId(prefix) {
-    const buf = crypto.getRandomValues(new Uint8Array(20));
-    const EPOCH_TIMESTAMP = 1700000000000;
-    const t = Date.now() - EPOCH_TIMESTAMP;
-    const high = Math.floor(t / 0x100000000);
-    const low = t >>> 0;
-    buf[0] = high >>> 24 & 255;
-    buf[1] = high >>> 16 & 255;
-    buf[2] = high >>> 8 & 255;
-    buf[3] = 255 & high;
-    buf[4] = low >>> 24 & 255;
-    buf[5] = low >>> 16 & 255;
-    buf[6] = low >>> 8 & 255;
-    buf[7] = 255 & low;
-    return `${prefix}_${b58.encode(buf)}`;
-}
-const currentDatabaseType = 'unknown';
-function getDatabaseType() {
-    return currentDatabaseType;
-}
-const fieldConfigSchema = z.object({
-    required: z.boolean().prefault(true),
-    returned: z.boolean().prefault(true),
-    input: z.boolean().prefault(true),
-    defaultValue: z.any().optional(),
-    transform: z.object({
-        input: z.any().optional(),
-        output: z.any().optional()
-    }).optional(),
-    validator: z.any().optional(),
-    unique: z.boolean().optional(),
-    indexed: z.boolean().optional(),
-    sortable: z.boolean().prefault(true),
-    fieldName: z.string().optional(),
-    bigint: z.boolean().prefault(false)
-});
-const stringFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('string'),
-    minLength: z.number().optional(),
-    maxLength: z.number().optional(),
-    pattern: z.string().optional()
-});
-const numberFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('number'),
-    min: z.number().optional(),
-    max: z.number().optional()
-});
-const booleanFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('boolean')
-});
-const dateFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('date'),
-    minDate: z.date().optional(),
-    maxDate: z.date().optional(),
-    dateOnly: z.boolean().prefault(false),
-    format: z.record(z.string(), z.unknown()).optional()
-});
-const timezoneFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('timezone'),
-    validateTimezone: z.boolean().prefault(true),
-    suggestedValues: z.array(z.string()).optional(),
-    restrictToSuggestedValues: z.boolean().prefault(false)
-});
-const jsonFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('json'),
-    validateJson: z.boolean().prefault(true)
-});
-const stringArrayFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('string[]')
-});
-const numberArrayFieldSchema = fieldConfigSchema.extend({
-    type: z.literal('number[]')
-});
-const fieldSchema = z.discriminatedUnion('type', [
-    stringFieldSchema,
-    numberFieldSchema,
-    booleanFieldSchema,
-    dateFieldSchema,
-    timezoneFieldSchema,
-    jsonFieldSchema,
-    stringArrayFieldSchema,
-    numberArrayFieldSchema
-]);
-function validateField(field) {
-    return fieldSchema.parse(field);
-}
-export { COMMON_TIMEZONES, generateId, getDatabaseType, validateField };

package/dist/pkgs/data-model/fields/superjson-utils.d.ts

@@ -1,12 +0,0 @@
-/**
- * Database type enumeration
- * Used to identify the current database type for data handling decisions
- */
-export type DatabaseType = 'sqlite' | 'postgresql' | 'mysql' | 'unknown';
-/**
- * Get the current database type
- *
- * @returns The current database type
- */
-export declare function getDatabaseType(): DatabaseType;
-//# sourceMappingURL=superjson-utils.d.ts.map

package/dist/pkgs/data-model/fields/superjson-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"superjson-utils.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/data-model/fields/superjson-utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,YAAY,GAAG,OAAO,GAAG,SAAS,CAAC;AAKzE;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAE9C"}

package/dist/pkgs/data-model/fields/zod-fields.d.ts

@@ -1,331 +0,0 @@
-import { z } from 'zod';
-import type { Field, FieldType } from './field-types';
-/**
- * Zod schema for string field configuration
- */
-export declare const stringFieldSchema: z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"string">;
-    minLength: z.ZodOptional<z.ZodNumber>;
-    maxLength: z.ZodOptional<z.ZodNumber>;
-    pattern: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Zod schema for number field configuration
- */
-export declare const numberFieldSchema: z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"number">;
-    min: z.ZodOptional<z.ZodNumber>;
-    max: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-/**
- * Zod schema for boolean field configuration
- */
-export declare const booleanFieldSchema: z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"boolean">;
-}, z.core.$strip>;
-/**
- * Zod schema for date field configuration
- */
-export declare const dateFieldSchema: z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"date">;
-    minDate: z.ZodOptional<z.ZodDate>;
-    maxDate: z.ZodOptional<z.ZodDate>;
-    dateOnly: z.ZodPrefault<z.ZodBoolean>;
-    format: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-/**
- * Zod schema for timezone field configuration
- */
-export declare const timezoneFieldSchema: z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"timezone">;
-    validateTimezone: z.ZodPrefault<z.ZodBoolean>;
-    suggestedValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    restrictToSuggestedValues: z.ZodPrefault<z.ZodBoolean>;
-}, z.core.$strip>;
-/**
- * Zod schema for JSON field configuration
- */
-export declare const jsonFieldSchema: z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"json">;
-    validateJson: z.ZodPrefault<z.ZodBoolean>;
-}, z.core.$strip>;
-/**
- * Zod schema for string array field configuration
- */
-export declare const stringArrayFieldSchema: z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"string[]">;
-}, z.core.$strip>;
-/**
- * Zod schema for number array field configuration
- */
-export declare const numberArrayFieldSchema: z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"number[]">;
-}, z.core.$strip>;
-/**
- * Union type of all field schemas
- */
-export declare const fieldSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"string">;
-    minLength: z.ZodOptional<z.ZodNumber>;
-    maxLength: z.ZodOptional<z.ZodNumber>;
-    pattern: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"number">;
-    min: z.ZodOptional<z.ZodNumber>;
-    max: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"boolean">;
-}, z.core.$strip>, z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"date">;
-    minDate: z.ZodOptional<z.ZodDate>;
-    maxDate: z.ZodOptional<z.ZodDate>;
-    dateOnly: z.ZodPrefault<z.ZodBoolean>;
-    format: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"timezone">;
-    validateTimezone: z.ZodPrefault<z.ZodBoolean>;
-    suggestedValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    restrictToSuggestedValues: z.ZodPrefault<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"json">;
-    validateJson: z.ZodPrefault<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"string[]">;
-}, z.core.$strip>, z.ZodObject<{
-    required: z.ZodPrefault<z.ZodBoolean>;
-    returned: z.ZodPrefault<z.ZodBoolean>;
-    input: z.ZodPrefault<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    transform: z.ZodOptional<z.ZodObject<{
-        input: z.ZodOptional<z.ZodAny>;
-        output: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>;
-    validator: z.ZodOptional<z.ZodAny>;
-    unique: z.ZodOptional<z.ZodBoolean>;
-    indexed: z.ZodOptional<z.ZodBoolean>;
-    sortable: z.ZodPrefault<z.ZodBoolean>;
-    fieldName: z.ZodOptional<z.ZodString>;
-    bigint: z.ZodPrefault<z.ZodBoolean>;
-    type: z.ZodLiteral<"number[]">;
-}, z.core.$strip>], "type">;
-/**
- * Type for a validated field configuration
- */
-export type ValidatedField<TFieldType extends FieldType> = z.infer<typeof fieldSchema> & {
-    type: TFieldType;
-};
-/**
- * Validates a field configuration against its schema
- */
-export declare function validateField<TFieldType extends FieldType>(field: Field<TFieldType>): ValidatedField<TFieldType>;
-//# sourceMappingURL=zod-fields.d.ts.map

package/dist/pkgs/data-model/fields/zod-fields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zod-fields.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/data-model/fields/zod-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAwBtD;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;iBAK5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;iBAI5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;iBAE7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;iBAM1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;iBAK9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;iBAG1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;iBAEjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;iBAEjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAStB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,UAAU,SAAS,SAAS,IAAI,CAAC,CAAC,KAAK,CACjE,OAAO,WAAW,CAClB,GAAG;IACH,IAAI,EAAE,UAAU,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,SAAS,SAAS,EACzD,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,GACtB,cAAc,CAAC,UAAU,CAAC,CAE5B"}

package/dist/pkgs/data-model/hooks/create-hooks.d.ts

@@ -1,32 +0,0 @@
-import type { Adapter } from '../../db-adapters';
-import type { CreateWithHooksProps, HookContext } from './types';
-/**
- * Creates a record with hooks applied before and after creation.
- *
- * @typeParam TInputData - Type of the data being created
- * @typeParam TOutputData - Type of the data returned after creation
- *
- * @param adapter - The database adapter to use
- * @param ctx - Context containing hooks and options
- * @param props - Properties for the create operation
- * @returns The created record or null if a hook aborted the operation
- *
- * @remarks
- * This function orchestrates the entity creation process, executing hooks
- * at appropriate times to allow validation, transformation, and post-processing.
- * It supports both standard adapter-based creation and custom creation functions.
- *
- * @example
- * ```typescript
- * const subject = await createWithHooks(
- *   mysqlAdapter,
- *   { hooks: subjectHooks, options: config },
- *   {
- *     data: { name: 'Alice' },
- *     model: 'subject'
- *   }
- * );
- * ```
- */
-export declare function createWithHooks<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData extends Record<string, unknown> = TInputData>(adapter: Adapter, ctx: HookContext, props: CreateWithHooksProps<TInputData>): Promise<TOutputData | null>;
-//# sourceMappingURL=create-hooks.d.ts.map

package/dist/pkgs/data-model/hooks/create-hooks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-hooks.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/data-model/hooks/create-hooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,eAAe,CACpC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,EAExD,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,oBAAoB,CAAC,UAAU,CAAC,GACrC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CA+C7B"}