@livon/schema 0.27.0-rc.1

package/dist/schema.d.ts

@@ -0,0 +1,132 @@
+import { Schema, SchemaContext, SchemaIssue, SchemaResult, SchemaErrorMeta, SchemaValidate, AstNode } from './types.js';
+import { TypeGuard } from './typeGuards.js';
+export interface CreateIssueInput {
+    path: readonly (string | number)[];
+    message: string;
+    code?: string;
+    context?: Readonly<Record<string, unknown>>;
+}
+export interface OkInput<T> {
+    value: T;
+}
+export interface FailInput {
+    issues: readonly SchemaIssue[];
+    meta?: SchemaErrorMeta;
+}
+export interface SchemaAstInternal {
+    (ctx: SchemaContext): AstNode;
+}
+export interface CreateSchemaInput<T> {
+    name: string;
+    type: string;
+    ast: SchemaAstInternal;
+    validate: SchemaValidate<T>;
+}
+export interface CreateGuardSchemaInput<T> {
+    name: string;
+    type: string;
+    guard: TypeGuard<T>;
+    message: string;
+    code?: string;
+}
+export interface SchemaGuard<T> {
+    (input: unknown): input is T;
+}
+export interface CreatePrimitiveSchemaInput<T> {
+    name: string;
+    type: string;
+    guard: SchemaGuard<T>;
+    message: string;
+    code?: string;
+}
+export interface EnsureSchemaContextInput {
+    context?: SchemaContext;
+    request?: SchemaContext['getRequestContext'];
+}
+export interface EnsureSchemaContext {
+    (ctx?: SchemaContext): SchemaContext;
+}
+/**
+ * createIssueForPath is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/type-safety
+ *
+ * @example
+ * const result = createIssueForPath(undefined as never);
+ */
+export declare const createIssueForPath: ({ path, message, code, context, }: CreateIssueInput) => SchemaIssue;
+/**
+ * ok is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/type-safety
+ *
+ * @example
+ * const result = ok(undefined as never);
+ */
+export declare const ok: <T>({ value }: OkInput<T>) => SchemaResult<T>;
+/**
+ * fail is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/type-safety
+ *
+ * @example
+ * const result = fail(undefined as never);
+ */
+export declare const fail: ({ issues, meta }: FailInput) => SchemaResult<never>;
+/**
+ * ensureSchemaContext is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/type-safety
+ *
+ * @example
+ * const result = ensureSchemaContext(undefined as never);
+ */
+export declare const ensureSchemaContext: EnsureSchemaContext;
+/**
+ * createSchema is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/type-safety
+ *
+ * @example
+ * const result = createSchema(undefined as never);
+ */
+export declare const createSchema: <T>({ name, type, ast, validate }: CreateSchemaInput<T>) => Schema<T>;
+/**
+ * createGuardSchema is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/type-safety
+ *
+ * @example
+ * const result = createGuardSchema(undefined as never);
+ */
+export declare const createGuardSchema: <T>({ name, type, guard, message, code }: CreateGuardSchemaInput<T>) => Schema<T>;
+/**
+ * createPrimitiveSchema is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/type-safety
+ *
+ * @example
+ * const result = createPrimitiveSchema(undefined as never);
+ */
+export declare const createPrimitiveSchema: <T>({ name, type, guard, message, code, }: CreatePrimitiveSchemaInput<T>) => Schema<T>;

package/dist/schema.js

@@ -0,0 +1,233 @@
+import { createSchemaValidationError } from "./SchemaValidationError.js";
+import { createSchemaContext, normalizeBuildContext, normalizeRequestContext } from "./context.js";
+import { mergeDoc, normalizeDoc } from "./doc.js";
+const createIssueForPath = ({ path, message, code, context })=>({
+        path,
+        message,
+        code,
+        context
+    });
+const ok = ({ value })=>({
+        ok: true,
+        value
+    });
+const fail = ({ issues, meta })=>({
+        ok: false,
+        issues,
+        meta
+    });
+const ensureSchemaContext = (ctx)=>{
+    if (ctx) return ctx;
+    const request = normalizeRequestContext();
+    return createSchemaContext({
+        request
+    });
+};
+const createSchema = ({ name, type, ast, validate })=>{
+    const validateWithContext = (input, ctx)=>{
+        const context = ensureSchemaContext(ctx);
+        if (!context.getRequestContext()) context.setRequestContext(normalizeRequestContext());
+        const build = context.getBuildContext();
+        const request = context.getRequestContext();
+        const meta = {
+            build,
+            request,
+            type,
+            name
+        };
+        const result = validate(input, context);
+        return result.ok ? result : fail({
+            issues: result.issues,
+            meta
+        });
+    };
+    const parse = (input, ctx)=>{
+        const result = validateWithContext(input, ctx);
+        if (result.ok) return result.value;
+        throw createSchemaValidationError({
+            issues: result.issues,
+            meta: result.meta
+        });
+    };
+    const typed = (input, ctx)=>parse(input, ctx);
+    const optional = ()=>createSchema({
+            name: `${name}.optional`,
+            type: `${type}.optional`,
+            ast,
+            validate: (input, ctx)=>void 0 === input ? ok({
+                    value: void 0
+                }) : validate(input, ctx)
+        });
+    const nullable = ()=>createSchema({
+            name: `${name}.nullable`,
+            type: `${type}.nullable`,
+            ast,
+            validate: (input, ctx)=>null === input ? ok({
+                    value: null
+                }) : validate(input, ctx)
+        });
+    const describe = (doc)=>{
+        const nextDoc = normalizeDoc(doc);
+        return createSchema({
+            name,
+            type,
+            ast: (ctx)=>{
+                const node = ast(ctx);
+                const merged = mergeDoc(node.doc, nextDoc);
+                return merged ? {
+                    ...node,
+                    doc: merged
+                } : node;
+            },
+            validate
+        });
+    };
+    const refine = ({ predicate, message, code })=>createSchema({
+            name: `${name}.refine`,
+            type: `${type}.refine`,
+            ast,
+            validate: (input, ctx)=>{
+                const context = ensureSchemaContext(ctx);
+                const result = validate(input, context);
+                if (!result.ok) return result;
+                return predicate(result.value, context) ? result : fail({
+                    issues: [
+                        createIssueForPath({
+                            path: [],
+                            message,
+                            code
+                        })
+                    ]
+                });
+            }
+        });
+    const before = (hook)=>createSchema({
+            name: `${name}.before`,
+            type: `${type}.before`,
+            ast,
+            validate: (input, ctx)=>{
+                const context = ensureSchemaContext(ctx);
+                const result = hook(input, context);
+                const issues = 'object' == typeof result && null !== result && 'issues' in result ? result.issues ?? [] : [];
+                if (issues.length > 0) return fail({
+                    issues
+                });
+                const nextInput = 'object' == typeof result && null !== result && 'input' in result ? result.input : result;
+                return validate(nextInput, context);
+            }
+        });
+    const after = (hook)=>createSchema({
+            name: `${name}.after`,
+            type: `${type}.after`,
+            ast,
+            validate: (input, ctx)=>{
+                const context = ensureSchemaContext(ctx);
+                const result = validate(input, context);
+                if (!result.ok) return result;
+                const hookResult = hook(result.value, context);
+                const issues = 'object' == typeof hookResult && null !== hookResult && 'issues' in hookResult ? hookResult.issues ?? [] : [];
+                if (issues.length > 0) return fail({
+                    issues
+                });
+                const nextValue = 'object' == typeof hookResult && null !== hookResult && 'value' in hookResult ? hookResult.value : hookResult;
+                return ok({
+                    value: nextValue
+                });
+            }
+        });
+    const and = (other)=>createSchema({
+            name: `${name}.and`,
+            type: `${type}.and`,
+            ast: (ctx)=>({
+                    type: 'and',
+                    children: [
+                        ast(ctx),
+                        other.ast(ctx.getBuildContext())
+                    ]
+                }),
+            validate: (input, ctx)=>{
+                const context = ensureSchemaContext(ctx);
+                const left = validate(input, context);
+                const right = other.validate(input, context);
+                return left.ok && right.ok ? ok({
+                    value: left.value
+                }) : fail({
+                    issues: [
+                        ...left.ok ? [] : left.issues,
+                        ...right.ok ? [] : right.issues
+                    ]
+                });
+            }
+        });
+    const resolveAst = (ctx)=>{
+        const node = ast(ctx);
+        return node.name ? node : {
+            ...node,
+            name
+        };
+    };
+    return {
+        name,
+        type,
+        ast: (input)=>{
+            const build = normalizeBuildContext(input ?? {});
+            const context = createSchemaContext({
+                build
+            });
+            return resolveAst(context);
+        },
+        validate: validateWithContext,
+        parse,
+        typed,
+        optional,
+        nullable,
+        describe,
+        refine,
+        before,
+        after,
+        and
+    };
+};
+const createGuardSchema = ({ name, type, guard, message, code })=>createSchema({
+        name,
+        type,
+        ast: ()=>({
+                type,
+                constraints: {
+                    kind: 'guard'
+                }
+            }),
+        validate: (input)=>guard(input) ? ok({
+                value: input
+            }) : fail({
+                issues: [
+                    createIssueForPath({
+                        path: [],
+                        message,
+                        code
+                    })
+                ]
+            })
+    });
+const createPrimitiveSchema = ({ name, type, guard, message, code })=>createSchema({
+        name,
+        type,
+        ast: ()=>({
+                type,
+                constraints: {
+                    kind: 'primitive'
+                }
+            }),
+        validate: (input)=>guard(input) ? ok({
+                value: input
+            }) : fail({
+                issues: [
+                    createIssueForPath({
+                        path: [],
+                        message,
+                        code
+                    })
+                ]
+            })
+    });
+export { createGuardSchema, createIssueForPath, createPrimitiveSchema, createSchema, ensureSchemaContext, fail, ok };