@declaro/data 2.0.0-beta.9 → 2.0.0-beta.90

package/src/domain/services/read-only-model-service.ts

@@ -0,0 +1,133 @@
+import type { AnyModelSchema } from '@declaro/core'
+import type {
+    InferDetail,
+    InferFilters,
+    InferLookup,
+    InferSearchResults,
+    InferSort,
+} from '../../shared/utils/schema-inference'
+import { ModelQueryEvent } from '../events/event-types'
+import { QueryEvent } from '../events/query-event'
+import { BaseModelService, type IActionOptions } from './base-model-service'
+import type { IPaginationInput } from '../models/pagination'
+import type { IUpdateOptions } from './model-service'
+
+export interface ILoadOptions extends IActionOptions {}
+export interface ISearchOptions<TSchema extends AnyModelSchema> extends IActionOptions {
+    pagination?: IPaginationInput
+    sort?: InferSort<TSchema>
+}
+
+export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseModelService<TSchema> {
+    /**
+     * Load a single record by its lookup criteria.
+     * @param lookup The lookup criteria to find the record.
+     * @param options Additional options for the load operation.
+     * @returns The loaded record details.
+     */
+    async load(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<InferDetail<TSchema>> {
+        // Emit the before load event
+        const beforeLoadEvent = new QueryEvent<InferDetail<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.BeforeLoad, options?.scope),
+            lookup,
+        )
+        await this.emitter.emitAsync(beforeLoadEvent)
+
+        // Load the details from the repository
+        const details = await this.repository.load(lookup)
+
+        // Emit the after load event
+        const afterLoadEvent = new QueryEvent<InferDetail<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.AfterLoad, options?.scope),
+            lookup,
+        ).setResult(details)
+        await this.emitter.emitAsync(afterLoadEvent)
+
+        return details
+    }
+
+    /**
+     * Load multiple records by their lookup criteria.
+     * @param lookups The lookup criteria to find the records.
+     * @param options Additional options for the load operation.
+     * @returns An array of loaded record details.
+     */
+    async loadMany(lookups: InferLookup<TSchema>[], options?: ILoadOptions): Promise<InferDetail<TSchema>[]> {
+        // Emit the before load many event
+        const beforeLoadManyEvent = new QueryEvent<InferDetail<TSchema>[], InferLookup<TSchema>[]>(
+            this.getDescriptor(ModelQueryEvent.BeforeLoadMany, options?.scope),
+            lookups,
+        )
+        await this.emitter.emitAsync(beforeLoadManyEvent)
+
+        // Load the details from the repository
+        const details = await this.repository.loadMany(lookups)
+
+        // Emit the after load many event
+        const afterLoadManyEvent = new QueryEvent<InferDetail<TSchema>[], InferLookup<TSchema>[]>(
+            this.getDescriptor(ModelQueryEvent.AfterLoadMany, options?.scope),
+            lookups,
+        ).setResult(details)
+        await this.emitter.emitAsync(afterLoadManyEvent)
+
+        return details
+    }
+
+    /**
+     * Search for records matching the given filters.
+     * @param filters The filters to apply to the search.
+     * @param options Additional options for the search operation.
+     * @returns The search results.
+     */
+    async search(
+        filters: InferFilters<TSchema>,
+        options?: ISearchOptions<TSchema>,
+    ): Promise<InferSearchResults<TSchema>> {
+        // Emit the before search event
+        const beforeSearchEvent = new QueryEvent<InferSearchResults<TSchema>, InferFilters<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.BeforeSearch, options?.scope),
+            filters,
+        )
+        await this.emitter.emitAsync(beforeSearchEvent)
+
+        // Search the repository with the provided filters
+        const results = await this.repository.search(filters, options)
+
+        // Emit the after search event
+        const afterSearchEvent = new QueryEvent<InferSearchResults<TSchema>, InferFilters<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.AfterSearch, options?.scope),
+            filters,
+        ).setResult(results)
+        await this.emitter.emitAsync(afterSearchEvent)
+
+        // Return the search results
+        return results
+    }
+
+    /**
+     * Count the number of records matching the given filters.
+     * @param filters The filters to apply to the count operation.
+     * @returns The count of matching records.
+     */
+    async count(filters: InferFilters<TSchema>, options?: ISearchOptions<TSchema>): Promise<number> {
+        // Emit the before count event
+        const beforeCountEvent = new QueryEvent<number, InferFilters<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.BeforeCount, options?.scope),
+            filters,
+        )
+        await this.emitter.emitAsync(beforeCountEvent)
+
+        // Count the records in the repository
+        const count = await this.repository.count(filters, options)
+
+        // Emit the after count event
+        const afterCountEvent = new QueryEvent<number, InferFilters<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.AfterCount, options?.scope),
+            filters,
+        ).setResult(count)
+        await this.emitter.emitAsync(afterCountEvent)
+
+        // Return the count
+        return count
+    }
+}

package/src/index.ts

@@ -1,4 +1,17 @@
-export * from './databaseConnection'
-export * from './serverConnection'
-export * from './datastoreAbstract'
-export * from './hydrateEntity'
+export * from './application/model-controller'
+export * from './application/read-only-model-controller'
+export * from './domain/events/domain-event'
+export * from './domain/events/event-types'
+export * from './domain/events/mutation-event'
+export * from './domain/events/query-event'
+export * from './domain/events/request-event'
+export * from './domain/interfaces/repository'
+export * from './domain/models/pagination'
+export * from './domain/services/base-model-service'
+export * from './domain/services/model-service'
+export * from './domain/services/model-service-args'
+export * from './domain/services/read-only-model-service'
+export * from './shared/utils/schema-inference'
+export * from './shared/utils/schema-inheritance'
+export * from './test/mock/models/mock-book-models'
+export * from './test/mock/repositories/mock-memory-repository'

package/src/shared/utils/schema-inference.ts

@@ -0,0 +1,26 @@
+import type { AnyModelSchema, InferModelInput, InferModelOutput } from '@declaro/core'
+import type { IPagination } from '../../domain/models/pagination'
+
+export interface ISearchResults<T> {
+    results: T[]
+    pagination: IPagination
+}
+
+export type InferLookup<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['lookup']>
+export type InferDetail<TSchema extends AnyModelSchema> = InferModelOutput<TSchema['definition']['detail']>
+export type InferFilters<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['filters']>
+export type InferSummary<TSchema extends AnyModelSchema> = InferModelOutput<TSchema['definition']['summary']>
+export type InferSort<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['sort']>
+export type InferInput<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['input']>
+export type InferSearchResults<TSchema extends AnyModelSchema> = ISearchResults<InferSummary<TSchema>>
+export type InferEntityMetadata<TSchema extends AnyModelSchema> = ReturnType<TSchema['getEntityMetadata']>
+export type InferPrimaryKeyType<TSchema extends AnyModelSchema> =
+    InferLookup<TSchema>[InferEntityMetadata<TSchema>['primaryKey']]
+
+export type InferSummarySchema<TSchema extends AnyModelSchema> = TSchema['definition']['summary']['schema']
+export type InferDetailSchema<TSchema extends AnyModelSchema> = TSchema['definition']['detail']['schema']
+export type InferLookupSchema<TSchema extends AnyModelSchema> = TSchema['definition']['lookup']['schema']
+export type InferInputSchema<TSchema extends AnyModelSchema> = TSchema['definition']['input']['schema']
+export type InferFiltersSchema<TSchema extends AnyModelSchema> = TSchema['definition']['filters']['schema']
+export type InferSortSchema<TSchema extends AnyModelSchema> = TSchema['definition']['sort']['schema']
+export type InferSearchResultsSchema<TSchema extends AnyModelSchema> = TSchema['definition']['search']['schema']

package/src/shared/utils/schema-inheritance.ts

@@ -0,0 +1,28 @@
+import type { AnyModelSchema, Model, ModelSchema } from '@declaro/core'
+import type { InferEntityMetadata } from './schema-inference'
+
+/**
+ * Represents a child schema that inherits from a parent schema.
+ * This is useful for creating schemas that extend the functionality of an existing schema.
+ * It replaces the schema name and all model names with a string type.
+ *
+ * @warning This type is intended for use in generic types. In most cases, you should use concrete schemas for inheritance for best type inference.
+ *
+ * @template TSchema - The parent schema type.
+ * @example
+ * ```ts
+ * import { ModelSchema, ChildSchema } from '@declaro/core';
+ *
+ * export class ParentService<TSchema extends ChildSchema<typeof ParentSchema>> extends ModelService<TSchema> {
+ *     constructor(args: IModelServiceArgs<TSchema>) {
+ *         super(args);
+ *     }
+ * }
+ */
+export type ChildSchema<TSchema extends AnyModelSchema> = ModelSchema<
+    string,
+    {
+        [K in keyof TSchema['definition']]: Model<string, TSchema['definition'][K]['schema']>
+    },
+    InferEntityMetadata<TSchema>
+>

package/src/test/mock/models/mock-book-models.ts

@@ -0,0 +1,78 @@
+import { ModelSchema } from '@declaro/core'
+import { sortArray, ZodModel } from '@declaro/zod'
+import { z } from 'zod/v4'
+import type {
+    InferFilters,
+    InferLookup,
+    InferDetail,
+    InferSummary,
+    InferSort,
+    InferInput,
+    InferSearchResults,
+    InferEntityMetadata,
+} from '../../../shared/utils/schema-inference'
+
+export const MockBookSchema = ModelSchema.create('Book')
+    .read({
+        detail: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    id: z.number().int().positive(),
+                    title: z.string().min(2).max(100),
+                    author: z.string().min(2).max(100),
+                    publishedDate: z.coerce.date(),
+                }),
+            ),
+        lookup: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    id: z.number().int().positive(),
+                }),
+            ),
+    })
+    .search({
+        filters: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    text: z.string().optional(),
+                }),
+            ),
+        summary: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    id: z.number().int().positive(),
+                    title: z.string().min(2).max(100),
+                    author: z.string().min(2).max(100),
+                    publishedDate: z.coerce.date(),
+                }),
+            ),
+        sort: (h) => new ZodModel(h.name, sortArray(['title', 'author'])),
+    })
+    .write({
+        input: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    id: z.number().int().positive().optional(),
+                    title: z.string().min(2).max(100),
+                    author: z.string().min(2).max(100),
+                    publishedDate: z.coerce.date(),
+                }),
+            ),
+    })
+    .entity({
+        primaryKey: 'id',
+    })
+
+export type MockBookFilters = InferFilters<typeof MockBookSchema>
+export type MockBookLookup = InferLookup<typeof MockBookSchema>
+export type MockBookDetail = InferDetail<typeof MockBookSchema>
+export type MockBookSummary = InferSummary<typeof MockBookSchema>
+export type MockBookSort = InferSort<typeof MockBookSchema>
+export type MockBookInput = InferInput<typeof MockBookSchema>
+export type MockBookSearchResults = InferSearchResults<typeof MockBookSchema>
+export type MockBookEntityMetadata = InferEntityMetadata<typeof MockBookSchema>