@declaro/core 2.0.0-y.0 → 2.1.1

package/src/pipelines/pipeline.test.ts

@@ -94,14 +94,16 @@ describe('Pipelines', () => {
                 number,
             }),
         )
-        const message = vi.fn((meta?: Meta) =>
-            meta?.positive
+        const message = vi.fn((meta: Meta | string): string =>
+            typeof meta === 'string'
+                ? meta
+                : meta?.positive
                 ? `${meta.number} is positive`
-                : meta.negative
+                : meta?.negative
                 ? `${meta.number} is negative`
-                : meta.zero
-                ? `${meta.number} is zero`
-                : `${meta.number} is not a number`,
+                : meta?.zero
+                ? `${meta?.number} is zero`
+                : `${meta?.number} is not a number`,
         )
 
         const originalPipeline = new Pipeline(initialInput<number>()).pipe(meta)
@@ -165,11 +167,11 @@ describe('Pipelines', () => {
 
             return meta?.positive
                 ? `${meta.number} is positive`
-                : meta.negative
+                : meta?.negative
                 ? `${meta.number} is negative`
-                : meta.zero
+                : meta?.zero
                 ? `${meta.number} is zero`
-                : `${meta.number} is not a number`
+                : `${meta?.number} is not a number`
         })
 
         const originalPipeline = new Pipeline(initialInput<number>()).pipe(meta)

package/src/schema/json-schema.ts

@@ -0,0 +1,16 @@
+import { type JSONSchema7 } from 'json-schema'
+
+export type JSONSchemaDefinition = JSONSchema | boolean
+
+export interface JSONMeta {
+    hidden?: boolean
+    private?: boolean
+}
+
+export interface JSONSchema extends JSONSchema7, JSONMeta {
+    properties?:
+        | {
+              [key: string]: JSONSchemaDefinition
+          }
+        | undefined
+}

package/src/schema/labels.ts

@@ -1,30 +1,30 @@
-import { capitalCase, camelCase, paramCase, pascalCase } from 'change-case'
+import { capitalCase, camelCase, kebabCase, pascalCase, sentenceCase } from 'change-case'
 import pluralize from 'pluralize'
 
-export type EntityLabels = {
-    singularLabel?: string
-    pluralLabel?: string
-    singularParameter?: string
-    pluralParameter?: string
-    singularSlug?: string
-    pluralSlug?: string
-    singularEntityName?: string
-    pluralEntityName?: string
-    singularTableName?: string
-    pluralTableName?: string
+export type ModelLabels = {
+    singularLabel: string
+    pluralLabel: string
+    singularSentence: string
+    pluralSentence: string
+    singularParameter: string
+    pluralParameter: string
+    singularSlug: string
+    pluralSlug: string
+    singularEntityName: string
+    pluralEntityName: string
 }
 
-export function getEntityLabels(entity: string, labels: Partial<EntityLabels> = {}): EntityLabels {
+export function getLabels(modelName: string, labels: Partial<ModelLabels> = {}): ModelLabels {
     return {
-        singularLabel: labels.singularLabel ?? capitalCase(pluralize(entity, 1)),
-        pluralLabel: labels.pluralLabel ?? capitalCase(pluralize(entity, 10)),
-        singularParameter: labels.singularParameter ?? camelCase(pluralize(entity, 1)),
-        pluralParameter: labels.pluralParameter ?? camelCase(pluralize(entity, 10)),
-        singularSlug: labels.singularSlug ?? paramCase(pluralize(entity, 1)),
-        pluralSlug: labels.pluralSlug ?? paramCase(pluralize(entity, 10)),
-        singularEntityName: labels.singularEntityName ?? pascalCase(pluralize(entity, 1)),
-        pluralEntityName: labels.pluralEntityName ?? pascalCase(pluralize(entity, 10)),
-        singularTableName: labels.singularTableName ?? paramCase(pluralize(entity, 1)),
-        pluralTableName: labels.pluralTableName ?? paramCase(pluralize(entity, 10)),
+        singularLabel: capitalCase(pluralize(labels.singularLabel ?? modelName, 1)),
+        pluralLabel: capitalCase(pluralize(labels.pluralLabel ?? modelName, 10)),
+        singularSentence: sentenceCase(pluralize(labels.singularLabel ?? modelName, 1)),
+        pluralSentence: sentenceCase(pluralize(labels.pluralLabel ?? modelName, 10)),
+        singularParameter: camelCase(pluralize(labels.singularParameter ?? modelName, 1)),
+        pluralParameter: camelCase(pluralize(labels.pluralParameter ?? modelName, 10)),
+        singularSlug: kebabCase(pluralize(labels.singularSlug ?? modelName, 1)),
+        pluralSlug: kebabCase(pluralize(labels.pluralSlug ?? modelName, 10)),
+        singularEntityName: pascalCase(pluralize(labels.singularEntityName ?? modelName, 1)),
+        pluralEntityName: pascalCase(pluralize(labels.pluralEntityName ?? modelName, 10)),
     }
 }

package/src/schema/model-schema.test.ts

@@ -0,0 +1,282 @@
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod/v4'
+import { ModelSchema, type MergeMixins } from './model-schema'
+import { MockModel } from './test/mock-model'
+import type { InferModelInput, InferModelOutput } from './model'
+import type { ShallowMerge, UniqueKeys } from '../typescript'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+
+describe('ModelSchema', () => {
+    it('should create a ModelSchema instance', () => {
+        const schema = ModelSchema.create('TestModel')
+        expect(schema).toBeInstanceOf(ModelSchema)
+        expect(schema.name).toBe('TestModel')
+    })
+
+    it('should support read definitions with MixinFactory', () => {
+        const schema = ModelSchema.create('Book').read({
+            detail: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+            lookup: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+        })
+
+        expect(schema.definition.detail).toBeInstanceOf(MockModel)
+        expect(schema.definition.lookup).toBeInstanceOf(MockModel)
+
+        const X = {} as any as InferModelOutput<(typeof schema)['definition']['lookup']>
+
+        expect(schema.definition.detail.name).toBe('BookDetail')
+        expect(schema.definition.lookup.name).toBe('BookLookup')
+    })
+
+    it('should support search definitions with MixinFactory', () => {
+        const schema = ModelSchema.create('Book').search({
+            filters: (h) =>
+                new MockModel(h.name, z.object({ title: z.string().optional(), author: z.string().optional() })),
+            summary: (h) => new MockModel(h.name, z.object({ id: z.string(), title: z.string() })),
+            sort: (h) =>
+                new MockModel(h.name, z.object({ title: z.enum(['asc', 'desc']), author: z.enum(['asc', 'desc']) })),
+        })
+
+        expect(schema.definition.filters).toBeInstanceOf(MockModel)
+        expect(schema.definition.summary).toBeInstanceOf(MockModel)
+        expect(schema.definition.filters.name).toBe('BookFilters')
+        expect(schema.definition.summary.name).toBe('BookSummary')
+    })
+
+    it('should support write definitions with MixinFactory', () => {
+        const schema = ModelSchema.create('Book').write({
+            input: (h) => new MockModel(h.name, z.object({ title: z.string(), author: z.string() })),
+        })
+
+        expect(schema.definition.input).toBeInstanceOf(MockModel)
+        expect(schema.definition.input.name).toBe('BookInput')
+    })
+
+    it('should define a primary key', () => {
+        const schema = ModelSchema.create('Book')
+            .read({
+                detail: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+                lookup: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+            })
+            .write({
+                input: (h) => new MockModel(h.name, z.object({ id: z.string(), title: z.string() })),
+            })
+            .entity({
+                primaryKey: 'id',
+            })
+
+        expect(schema.getEntityMetadata().primaryKey).toBe('id')
+    })
+
+    it('should allow redefinition of types', () => {
+        const schema = ModelSchema.create('Book')
+            .read({
+                detail: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+                lookup: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+            })
+            .write({
+                input: (h) => new MockModel(h.name, z.object({ id: z.string(), title: z.string() })),
+            })
+            .entity({
+                primaryKey: 'id',
+            })
+
+        const redefinedSchema = schema.read({
+            detail: (h) =>
+                new MockModel(
+                    h.name,
+                    z.object({ id: z.number(), name: z.string().optional(), age: z.number().optional() }),
+                ),
+            lookup: (h) => new MockModel(h.name, z.object({ id: z.number() })),
+        })
+
+        const patchedSchema = redefinedSchema.custom({
+            detail: () =>
+                new MockModel(
+                    'BookDetail',
+                    z.object({ id: z.string(), name: z.string(), foo: z.string(), bar: z.string() }),
+                ),
+        })
+
+        const detailSchema = redefinedSchema.definition.detail.toJSONSchema()
+        const patchedDetailSchema = patchedSchema.definition.detail.toJSONSchema()
+
+        expect(redefinedSchema.definition.detail).toBeInstanceOf(MockModel)
+        expect(Object.keys(detailSchema.properties ?? {})).toEqual(['id', 'name', 'age'])
+
+        expect(Object.keys(patchedDetailSchema.properties ?? {})).toEqual(['id', 'name', 'foo', 'bar'])
+    })
+
+    it('should be able to redefine schema without changes to the primary key', () => {
+        const schema = ModelSchema.create('Book')
+            .read({
+                detail: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+                lookup: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+            })
+            .write({
+                input: (h) => new MockModel(h.name, z.object({ id: z.string(), title: z.string() })),
+            })
+            .entity({
+                primaryKey: 'id',
+            })
+            .read({
+                detail: (h) => new MockModel(h.name, z.object({ uuid: z.string(), name: z.string() })),
+                lookup: (h) => new MockModel(h.name, z.object({ uuid: z.string(), name: z.string() })),
+            })
+
+        expect(schema.getEntityMetadata().primaryKey).toBe('id')
+    })
+
+    it('should be able to manually strip private and hidden keys from input', () => {
+        const testModel = new MockModel(
+            'TestModel',
+            z.object({
+                id: z.string(),
+                name: z.string(),
+                secret: z.string().optional().meta({ private: true }),
+                internalNote: z.string().optional().meta({ hidden: true }),
+            }),
+        )
+
+        const payload: InferModelInput<typeof testModel> = {
+            id: '1',
+            name: 'Test',
+            secret: 'top-secret',
+            internalNote: 'for-internal-use-only',
+        }
+
+        const stripped = testModel.stripExcludedFields(payload)
+
+        expect(stripped).toEqual({
+            id: '1',
+            name: 'Test',
+            internalNote: 'for-internal-use-only',
+        })
+    })
+
+    it('should strip private fields from validation input', async () => {
+        const testModel = new MockModel(
+            'TestModel',
+            z.object({
+                id: z.string(),
+                name: z.string(),
+                secret: z.string().optional().meta({ private: true }),
+                internalNote: z.string().optional().meta({ hidden: true }),
+            }),
+        )
+
+        const payload: InferModelInput<typeof testModel> = {
+            id: '1',
+            name: 'Test',
+            secret: 'top-secret',
+            internalNote: 'for-internal-use-only',
+        }
+
+        const validation = await testModel.validate(payload, { strict: false })
+
+        expect(validation.issues).toBeUndefined()
+
+        const output = (validation as StandardSchemaV1.SuccessResult<InferModelOutput<typeof testModel>>).value
+
+        expect(output.secret).toBeUndefined()
+    })
+
+    it('should not strip hidden fields from validation input', async () => {
+        const testModel = new MockModel(
+            'TestModel',
+            z.object({
+                id: z.string(),
+                name: z.string(),
+                secret: z.string().optional().meta({ private: true }),
+                internalNote: z.string().optional().meta({ hidden: true }),
+            }),
+        )
+
+        const payload: InferModelInput<typeof testModel> = {
+            id: '1',
+            name: 'Test',
+            secret: 'top-secret',
+            internalNote: 'for-internal-use-only',
+        }
+
+        const validation = await testModel.validate(payload, { strict: false })
+
+        expect(validation.issues).toBeUndefined()
+
+        const output = (validation as StandardSchemaV1.SuccessResult<InferModelOutput<typeof testModel>>).value
+
+        expect(output.internalNote).toBe('for-internal-use-only')
+    })
+
+    it('should strip private fields from model schema by default', () => {
+        const testModel = new MockModel(
+            'TestModel',
+            z.object({
+                id: z.string(),
+                name: z.string(),
+                secret: z.string().optional().meta({ private: true }),
+                internalNote: z.string().optional().meta({ hidden: true }),
+            }),
+        )
+
+        const jsonSchema = testModel.toJSONSchema()
+
+        expect(Object.keys(jsonSchema.properties!)).toEqual(['id', 'name', 'internalNote'])
+    })
+
+    it('should not strip hidden fields from model schema', () => {
+        const testModel = new MockModel(
+            'TestModel',
+            z.object({
+                id: z.string(),
+                name: z.string(),
+                secret: z.string().optional().meta({ private: true }),
+                internalNote: z.string().optional().meta({ hidden: true }),
+            }),
+        )
+
+        const jsonSchema = testModel.toJSONSchema({ includePrivateFields: false })
+
+        expect(Object.keys(jsonSchema.properties!)).toEqual(['id', 'name', 'internalNote'])
+    })
+
+    it('should not strip private fields from model schema when specified', () => {
+        const testModel = new MockModel(
+            'TestModel',
+            z.object({
+                id: z.string(),
+                name: z.string(),
+                secret: z.string().optional().meta({ private: true }),
+                internalNote: z.string().optional().meta({ hidden: true }),
+            }),
+        )
+
+        const jsonSchema = testModel.toJSONSchema({ includePrivateFields: true })
+
+        expect(Object.keys(jsonSchema.properties!)).toEqual(['id', 'name', 'secret', 'internalNote'])
+    })
+
+    it('should include hidden fields in model schema when specified', () => {
+        const testModel = new MockModel(
+            'TestModel',
+            z.object({
+                id: z.string(),
+                name: z.string(),
+                secret: z.string().optional().meta({ private: true }),
+                internalNote: z.string().optional().meta({ hidden: true }),
+            }),
+        )
+
+        const jsonSchema = testModel.toJSONSchema()
+
+        expect(Object.keys(jsonSchema.properties!)).toEqual(['id', 'name', 'internalNote'])
+
+        const internalNoteSchema = jsonSchema.properties?.['internalNote']
+
+        if (typeof internalNoteSchema === 'object') {
+            expect(internalNoteSchema.hidden).toBe(true)
+        } else {
+            throw new Error('internalNote schema is not an object')
+        }
+    })
+})

package/src/schema/model-schema.ts

@@ -0,0 +1,197 @@
+import { merge } from '../dataflow'
+import type { Merge, ShallowMerge } from '../typescript'
+import { getLabels, type ModelLabels } from './labels'
+import { type InferModelInput } from './model'
+import {
+    buildMixin,
+    defineMixin,
+    type IAnyMixin,
+    type IMixin,
+    type IMixinHelper,
+    type IMixinHelpers,
+    type IMixinInput,
+    type InferMixinInput,
+} from './schema-mixin'
+import { MockModel } from './test/mock-model'
+import { z } from 'zod/v4'
+
+export type Subset<T> = {
+    [K in keyof T]?: T[K]
+}
+export type Simplify<T> = { [K in keyof T]: T[K] } & {}
+
+export type MergeMixins<TA extends IAnyMixin | undefined, TB extends IAnyMixin> = Simplify<
+    TA extends IAnyMixin ? ShallowMerge<TA, TB> : TB
+>
+
+export function getReadHelpers<TName extends Readonly<string>>(h: IMixinHelper<TName>) {
+    return {
+        detail: { name: h.name },
+        lookup: { name: `${h.name}Lookup` as const },
+    }
+}
+
+const readMixin = defineMixin((h) => ({
+    detail: {
+        name: `${h.name}Detail` as const,
+    },
+    lookup: {
+        name: `${h.name}Lookup` as const,
+    },
+}))
+export type ReadMixin<TName extends Readonly<string>> = ReturnType<typeof readMixin<TName>>
+
+const defaultMixin = defineMixin((h) => ({}))
+export type DefaultMixin<TName extends Readonly<string>> = ReturnType<typeof defaultMixin<TName>>
+
+const searchMixin = defineMixin((h) => ({
+    summary: { name: `${h.name}Summary` as const },
+    filters: { name: `${h.name}Filters` as const },
+    sort: { name: `${h.name}Sort` as const },
+}))
+export type SearchMixin<TName extends Readonly<string>> = ReturnType<typeof searchMixin<TName>>
+
+const writeMixin = defineMixin((h) => ({
+    input: { name: `${h.name}Input` as const },
+}))
+export type WriteMixin<TName extends Readonly<string>> = ReturnType<typeof writeMixin<TName>>
+
+export type IModelNames<T extends object> = {
+    [K in keyof T]: Readonly<string>
+}
+
+export type InferPKeyBaseType<T extends IAnyMixin | undefined> = T extends IAnyMixin
+    ? T['lookup'] extends object
+        ? keyof InferModelInput<T['lookup']> | undefined
+        : undefined
+    : undefined
+
+export interface IModelEntityMetadata {
+    primaryKey: string
+}
+
+export class ModelSchema<
+    TName extends Readonly<string> = Readonly<string>,
+    T extends IAnyMixin | undefined = undefined,
+    TEntityMeta extends IModelEntityMetadata | undefined = undefined,
+> {
+    static create<TName extends Readonly<string>>(name: TName): ModelSchema<TName> {
+        return new ModelSchema(name)
+    }
+
+    public readonly definition: Simplify<T>
+    public readonly name: TName
+    protected readonly entityMetadata: TEntityMeta
+
+    constructor(name: TName, definition: T = {} as T, entityMetadata?: TEntityMeta) {
+        this.definition = definition
+        this.name = name
+        this.entityMetadata = entityMetadata!
+    }
+
+    get labels(): ModelLabels {
+        return getLabels(this.name)
+    }
+
+    get helper(): IMixinHelper<TName> {
+        return {
+            name: this.name,
+        }
+    }
+
+    custom<TInput extends IMixinInput>(input: TInput): ModelSchema<TName, MergeMixins<T, IMixin<TInput>>, TEntityMeta> {
+        const helpers: IMixinHelpers<TInput> = Object.keys(input).reduce((acc: any, key) => {
+            const helper = this.helper
+            acc[key] = helper
+            return acc
+        }, {} as IMixinHelpers<TInput>)
+        const definition = buildMixin(helpers, input as any)
+
+        return new ModelSchema(
+            this.name,
+            {
+                ...this.definition,
+                ...definition,
+            },
+            this.entityMetadata,
+        ) as any
+    }
+
+    read<TInput extends InferMixinInput<ReadMixin<TName>>>(
+        input: TInput,
+    ): ModelSchema<TName, MergeMixins<T, IMixin<TInput>>, TEntityMeta> {
+        const helpers = readMixin(this.helper)
+        const definition = buildMixin(helpers, input)
+
+        return new ModelSchema(
+            this.name,
+            {
+                ...this.definition,
+                ...definition,
+            },
+            this.entityMetadata,
+        ) as any
+    }
+
+    search<TInput extends InferMixinInput<SearchMixin<TName>>>(
+        input: TInput,
+    ): ModelSchema<TName, MergeMixins<T, IMixin<TInput>>> {
+        const helpers = searchMixin(this.helper)
+        const definition = buildMixin(helpers, input)
+
+        return new ModelSchema(
+            this.name,
+            {
+                ...this.definition,
+                ...definition,
+            },
+            this.entityMetadata,
+        ) as any
+    }
+
+    write<TInput extends InferMixinInput<WriteMixin<TName>>>(
+        input: TInput,
+    ): ModelSchema<TName, MergeMixins<T, IMixin<TInput>>> {
+        const helpers = writeMixin(this.helper)
+        const definition = buildMixin(helpers, input)
+
+        return new ModelSchema(
+            this.name,
+            {
+                ...this.definition,
+                ...definition,
+            },
+            this.entityMetadata,
+        ) as any
+    }
+
+    entity<
+        TEntityMeta extends {
+            primaryKey: InferPKeyBaseType<T>
+        },
+    >(meta: TEntityMeta): ModelSchema<TName, T, TEntityMeta extends IModelEntityMetadata ? TEntityMeta : undefined> {
+        const lookupMeta = this.definition?.['lookup']?.toJSONSchema()
+        const lookupKeys = Object.keys(lookupMeta?.properties ?? {})
+
+        const metaIsValid = meta && typeof meta.primaryKey === 'string' && lookupKeys.includes(meta.primaryKey)
+        return new ModelSchema<TName, T, TEntityMeta extends IModelEntityMetadata ? TEntityMeta : undefined>(
+            this.name,
+            this.definition,
+            metaIsValid ? (meta as any) : undefined,
+        )
+    }
+
+    getEntityMetadata(): TEntityMeta {
+        return this.entityMetadata
+    }
+}
+
+export type AnyModelSchema = ModelSchema<any, any, any>
+
+const test = ModelSchema.create('Test').read({
+    detail: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+    lookup: (h) => new MockModel(h.name, z.object({ id: z.string(), name: z.string() })),
+})
+
+const d = test.definition
+const l = {} as any as keyof InferModelInput<typeof test.definition.lookup>