@declaro/data 2.0.0-beta.14 → 2.0.0-beta.140

package/src/test/mock/repositories/mock-memory-repository.ts

@@ -0,0 +1,401 @@
+import type { AnyModelSchema, IModelEntityMetadata, JSONSchema, Model } from '@declaro/core'
+import type { IRepository } from '../../../domain/interfaces/repository'
+import type { IPaginationInput } from '../../../domain/models/pagination'
+import type {
+    InferDetail,
+    InferFilters,
+    InferInput,
+    InferLookup,
+    InferSearchResults,
+    InferSummary,
+} from '../../../shared/utils/schema-inference'
+import { v4 as uuid } from 'uuid'
+import type { ILoadOptions, ISearchOptions } from '../../../domain/services/read-only-model-service'
+import type { ICreateOptions, IUpdateOptions } from '../../../domain/services/model-service'
+
+export interface IMockMemoryRepositoryArgs<TSchema extends AnyModelSchema> {
+    schema: TSchema
+    lookup?: (data: InferDetail<TSchema>, lookup: InferLookup<TSchema>) => boolean
+    filter?: (data: InferSummary<TSchema>, filters: InferFilters<TSchema>) => boolean
+    assign?: (data: InferDetail<TSchema>, input: InferInput<TSchema>) => InferDetail<TSchema>
+}
+
+export class MockMemoryRepository<TSchema extends AnyModelSchema> implements IRepository<TSchema> {
+    protected data = new Map<string, InferDetail<TSchema>>()
+    protected trash = new Map<string, InferDetail<TSchema>>()
+    protected entityMetadata: IModelEntityMetadata
+    protected nextId: number = 0
+
+    constructor(protected args: IMockMemoryRepositoryArgs<TSchema>) {
+        this.entityMetadata = this.args.schema.getEntityMetadata()
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key must be specified for MockMemoryRepository')
+        }
+    }
+
+    private findOne(
+        lookup: InferLookup<TSchema>,
+        map: Map<string, InferDetail<TSchema>>,
+    ): InferDetail<TSchema> | undefined {
+        if (typeof this.args.lookup === 'function') {
+            return Array.from(map.values()).find((data) => this.args.lookup!(data, lookup))
+        } else {
+            // Default lookup by primary key
+            return map.get(lookup[this.entityMetadata.primaryKey])
+        }
+    }
+
+    /**
+     * Find an item and return both the item and its key
+     * @param lookup - The lookup criteria
+     * @param map - The map to search in
+     * @returns Object containing the item and its key, or undefined if not found
+     */
+    private findOneWithKey(
+        lookup: InferLookup<TSchema>,
+        map: Map<string, InferDetail<TSchema>>,
+    ): { item: InferDetail<TSchema>; key: string } | undefined {
+        if (typeof this.args.lookup === 'function') {
+            const item = Array.from(map.values()).find((data) => this.args.lookup!(data, lookup))
+            if (item) {
+                return { item, key: item[this.entityMetadata.primaryKey!] }
+            }
+        } else {
+            // Default lookup by primary key
+            const key = lookup[this.entityMetadata.primaryKey]
+            const item = map.get(key)
+            if (item) {
+                return { item, key }
+            }
+        }
+        return undefined
+    }
+
+    /**
+     * Loads a single item by lookup criteria.
+     * @param input - The lookup criteria.
+     * @param options - Optional load options including removedOnly and includeRemoved.
+     * @returns The found item or null if not found.
+     */
+    async load(input: InferLookup<TSchema>, options: ILoadOptions = {}): Promise<InferDetail<TSchema> | null> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        let item: InferDetail<TSchema> | undefined
+
+        if (options.removedOnly) {
+            item = this.findOne(input, this.trash)
+        } else if (options.includeRemoved) {
+            item = this.findOne(input, this.data) ?? this.findOne(input, this.trash)
+        } else {
+            item = this.findOne(input, this.data)
+        }
+
+        return item || null
+    }
+    async loadMany(inputs: InferLookup<TSchema>[]): Promise<InferDetail<TSchema>[]> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        const results: InferDetail<TSchema>[] = []
+        for (const input of inputs) {
+            let item: InferDetail<TSchema> | undefined
+            if (typeof this.args.lookup === 'function') {
+                item = Array.from(this.data.values()).find((data) => this.args.lookup!(data, input))
+            } else {
+                // Default lookup by primary key
+                item = this.data.get(input[this.entityMetadata.primaryKey!])
+            }
+            if (item) {
+                results.push(item)
+            }
+        }
+        return results
+    }
+    async search(
+        input: InferFilters<TSchema>,
+        options?: ISearchOptions<TSchema>,
+    ): Promise<InferSearchResults<TSchema>> {
+        const pagination = options?.pagination || { page: 1, pageSize: 25 }
+        let items = this.applyFilters(input, options)
+
+        // Apply sorting if provided
+        if (options?.sort && Array.isArray(options.sort)) {
+            items = items.sort((a, b) => {
+                for (const sortField of options.sort! as any[]) {
+                    for (const [field, direction] of Object.entries(sortField)) {
+                        if (!direction || typeof direction !== 'string') continue
+
+                        const aValue = a[field as keyof typeof a]
+                        const bValue = b[field as keyof typeof b]
+
+                        let comparison = 0
+                        if (aValue < bValue) comparison = -1
+                        else if (aValue > bValue) comparison = 1
+
+                        if (comparison !== 0) {
+                            // Handle different sort directions
+                            const isDesc = direction.includes('desc')
+                            return isDesc ? -comparison : comparison
+                        }
+                    }
+                }
+                return 0
+            })
+        }
+
+        return {
+            results: items.slice(
+                ((pagination?.page ?? 1) - 1) * (pagination?.pageSize ?? 25),
+                (pagination?.page ?? 1) * (pagination?.pageSize ?? 25),
+            ),
+            pagination: {
+                total: items.length,
+                totalPages: Math.ceil(items.length / (pagination?.pageSize ?? 25)),
+                ...pagination,
+                page: pagination?.page ?? 1,
+                pageSize: pagination?.pageSize ?? 25,
+            },
+        }
+    }
+    async remove(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        const found = this.findOneWithKey(lookup, this.data)
+        if (!found) {
+            throw new Error('Item not found')
+        }
+
+        // Move the item to trash
+        this.trash.set(found.key, found.item)
+        // Remove the item from data
+        this.data.delete(found.key)
+        return found.item
+    }
+    async restore(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        const found = this.findOneWithKey(lookup, this.trash)
+        if (!found) {
+            throw new Error('Item not found in trash')
+        }
+
+        this.trash.delete(found.key)
+        this.data.set(found.key, found.item)
+        return found.item
+    }
+
+    async create(input: InferInput<TSchema>): Promise<InferDetail<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+        const primaryKeyValue = input[this.entityMetadata.primaryKey]
+
+        if (primaryKeyValue && this.data.has(primaryKeyValue)) {
+            throw new Error('Item with the same primary key already exists')
+        }
+
+        const baseData = {} as InferDetail<TSchema>
+        const payload = this.assignInput(baseData, input)
+
+        if (!payload[this.entityMetadata.primaryKey]) {
+            // Generate a new primary key if not provided
+            payload[this.entityMetadata.primaryKey!] = await this.generatePrimaryKey()
+        }
+
+        this.data.set(payload[this.entityMetadata.primaryKey!], payload)
+        return payload
+    }
+
+    async update(lookup: InferLookup<TSchema>, input: InferInput<TSchema>): Promise<InferDetail<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        let existingItem: InferDetail<TSchema> | undefined
+        let itemKey: string
+
+        if (typeof this.args.lookup === 'function') {
+            existingItem = Array.from(this.data.values()).find((data) => this.args.lookup!(data, lookup))
+            if (existingItem) {
+                itemKey = existingItem[this.entityMetadata.primaryKey!]
+            } else {
+                throw new Error('Item not found')
+            }
+        } else {
+            // Default lookup by primary key
+            itemKey = lookup[this.entityMetadata.primaryKey]
+            if (!itemKey) {
+                throw new Error('Primary key value must be provided')
+            }
+            existingItem = this.data.get(itemKey)
+            if (!existingItem) {
+                throw new Error('Item not found')
+            }
+        }
+
+        const updatedItem = this.assignInput(existingItem, input)
+        this.data.set(itemKey!, updatedItem)
+        return updatedItem
+    }
+
+    async count(search: InferFilters<TSchema>, options?: ISearchOptions<TSchema> | undefined): Promise<number> {
+        const filteredItems = this.applyFilters(search, options)
+        return filteredItems.length
+    }
+
+    async upsert(input: InferInput<TSchema>, options?: ICreateOptions | IUpdateOptions): Promise<InferDetail<TSchema>> {
+        const primaryKeyValue = input[this.entityMetadata.primaryKey]
+        let existingItem: InferDetail<TSchema> = {} as InferDetail<TSchema>
+
+        if (primaryKeyValue) {
+            existingItem = this.data.get(primaryKeyValue) ?? ({} as InferDetail<TSchema>)
+        }
+
+        const updatedItem = this.assignInput(existingItem, input)
+        if (!updatedItem[this.entityMetadata.primaryKey!]) {
+            updatedItem[this.entityMetadata.primaryKey!] = await this.generatePrimaryKey()
+        }
+
+        this.data.set(updatedItem[this.entityMetadata.primaryKey!], updatedItem)
+
+        return updatedItem
+    }
+
+    async bulkUpsert(
+        inputs: InferInput<TSchema>[],
+        options?: ICreateOptions | IUpdateOptions,
+    ): Promise<InferDetail<TSchema>[]> {
+        return await Promise.all(inputs.map((input) => this.upsert(input, options)))
+    }
+
+    async permanentlyDelete(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        // Try to find in main data first, then trash
+        const foundInData = this.findOneWithKey(lookup, this.data)
+        if (foundInData) {
+            this.data.delete(foundInData.key)
+            return foundInData.item
+        }
+
+        const foundInTrash = this.findOneWithKey(lookup, this.trash)
+        if (foundInTrash) {
+            this.trash.delete(foundInTrash.key)
+            return foundInTrash.item
+        }
+
+        throw new Error('Item not found')
+    }
+
+    async permanentlyDeleteFromTrash(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        const found = this.findOneWithKey(lookup, this.trash)
+        if (!found) {
+            throw new Error('Item not found in trash')
+        }
+
+        this.trash.delete(found.key)
+        return found.item
+    }
+
+    async emptyTrash(filters?: InferFilters<TSchema>): Promise<number> {
+        if (!filters || Object.keys(filters).length === 0) {
+            // Delete all items from trash
+            const count = this.trash.size
+            this.trash.clear()
+            return count
+        }
+
+        // Apply filters to trash items
+        const itemsToDelete: string[] = []
+        for (const [key, item] of this.trash.entries()) {
+            if (typeof this.args.filter === 'function') {
+                if (this.args.filter(item, filters)) {
+                    itemsToDelete.push(key)
+                }
+            } else {
+                // No filter function provided - match all items
+                itemsToDelete.push(key)
+            }
+        }
+
+        // Delete filtered items
+        for (const key of itemsToDelete) {
+            this.trash.delete(key)
+        }
+
+        return itemsToDelete.length
+    }
+
+    /**
+     * Apply filtering logic to all items based on the provided search criteria
+     * @param input - The search/filter criteria
+     * @param options - Optional search options including removedOnly and includeRemoved
+     * @returns Filtered array of items
+     */
+    protected applyFilters(input: InferFilters<TSchema>, options?: ISearchOptions<TSchema>): InferDetail<TSchema>[] {
+        let sourceItems: InferDetail<TSchema>[]
+
+        if (options?.removedOnly) {
+            // Only search in trash
+            sourceItems = Array.from(this.trash.values())
+        } else if (options?.includeRemoved) {
+            // Search in both data and trash
+            sourceItems = [...Array.from(this.data.values()), ...Array.from(this.trash.values())]
+        } else {
+            // Default: only search in active data
+            sourceItems = Array.from(this.data.values())
+        }
+
+        return sourceItems.filter((item) => {
+            // Apply filtering logic based on the input
+            if (typeof this.args.filter === 'function') {
+                return this.args.filter(item, input)
+            } else {
+                return true
+            }
+        })
+    }
+
+    /**
+     * Assign input data to existing data using the provided assign function or default Object.assign
+     * @param existingData - The existing data to merge with
+     * @param input - The input data to assign
+     * @returns The merged data
+     */
+    protected assignInput(existingData: InferDetail<TSchema>, input: InferInput<TSchema>): InferDetail<TSchema> {
+        if (typeof this.args.assign === 'function') {
+            return this.args.assign(existingData, input)
+        } else {
+            // Default implementation using Object.assign
+            return Object.assign({}, existingData, input) as InferDetail<TSchema>
+        }
+    }
+
+    protected async generatePrimaryKey() {
+        const lookupModel: Model<any, any> = this.args.schema.definition.lookup
+        const lookupMeta = await lookupModel.toJSONSchema()
+        const primaryKeyMeta = lookupMeta.properties?.[this.entityMetadata.primaryKey!] as JSONSchema
+        const type = primaryKeyMeta.type as string
+
+        if (type === 'string') {
+            return uuid()
+        } else if (['number', 'integer'].includes(type)) {
+            return ++this.nextId
+        } else {
+            throw new Error(`Unsupported primary key type: ${type}`)
+        }
+    }
+}

package/src/test/mock/repositories/mock-memory-repository.upsert.test.ts

@@ -0,0 +1,108 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { MockBookSchema } from '../models/mock-book-models'
+import { MockMemoryRepository } from './mock-memory-repository'
+
+describe('MockMemoryRepository - Upsert Functionality', () => {
+    const mockSchema = MockBookSchema
+
+    let repository: MockMemoryRepository<typeof mockSchema>
+
+    beforeEach(() => {
+        repository = new MockMemoryRepository({ schema: mockSchema })
+    })
+
+    it('should create a new item when no existing item with primary key exists', async () => {
+        const input = { id: 42, title: 'New Book', author: 'Author Name', publishedDate: new Date() }
+
+        const upsertedItem = await repository.upsert(input)
+
+        expect(upsertedItem).toEqual(input)
+        expect(await repository.load({ id: 42 })).toEqual(input)
+    })
+
+    it('should update an existing item when primary key matches', async () => {
+        // Create initial item
+        const initial = {
+            id: 42,
+            title: 'Original Book',
+            author: 'Original Author',
+            publishedDate: new Date('2023-01-01'),
+        }
+        await repository.create(initial)
+
+        // Upsert with same ID but different data
+        const update = {
+            id: 42,
+            title: 'Updated Book',
+            author: 'Updated Author',
+            publishedDate: new Date('2023-12-01'),
+        }
+        const upsertedItem = await repository.upsert(update)
+
+        expect(upsertedItem).toEqual(update)
+        expect(await repository.load({ id: 42 })).toEqual(update)
+    })
+
+    it('should generate primary key when upserting without one', async () => {
+        const input = { title: 'Book Without ID', author: 'Author Name', publishedDate: new Date() }
+
+        const upsertedItem = await repository.upsert(input)
+
+        expect(upsertedItem.id).toBeDefined()
+        expect(upsertedItem.title).toBe(input.title)
+        expect(upsertedItem.author).toBe(input.author)
+        expect(await repository.load({ id: upsertedItem.id })).toEqual(upsertedItem)
+    })
+
+    it('should merge with existing item properties when updating', async () => {
+        // Create initial item with multiple properties
+        const initial = {
+            id: 42,
+            title: 'Original Book',
+            author: 'Original Author',
+            publishedDate: new Date('2023-01-01'),
+        }
+        await repository.create(initial)
+
+        // Upsert with partial update (only title) - need to provide required fields
+        const partialUpdate = {
+            id: 42,
+            title: 'Updated Title',
+            author: 'Original Author', // Keep original
+            publishedDate: new Date('2023-01-01'), // Keep original
+        }
+        const upsertedItem = await repository.upsert(partialUpdate)
+
+        // Should have updated title but kept other properties
+        expect(upsertedItem.id).toBe(42)
+        expect(upsertedItem.title).toBe('Updated Title')
+        expect(upsertedItem.author).toBe('Original Author')
+        expect(upsertedItem.publishedDate).toEqual(initial.publishedDate)
+    })
+
+    it('should handle upsert with null/undefined primary key', async () => {
+        const input = {
+            id: undefined,
+            title: 'Book With Undefined ID',
+            author: 'Author Name',
+            publishedDate: new Date(),
+        }
+
+        const upsertedItem = await repository.upsert(input)
+
+        expect(upsertedItem.id).toBeDefined()
+        expect(typeof upsertedItem.id).toBe('number')
+        expect(upsertedItem.title).toBe(input.title)
+    })
+
+    it('should increment auto-generated IDs correctly', async () => {
+        const input1 = { title: 'Book 1', author: 'Author 1', publishedDate: new Date() }
+        const input2 = { title: 'Book 2', author: 'Author 2', publishedDate: new Date() }
+
+        const item1 = await repository.upsert(input1)
+        const item2 = await repository.upsert(input2)
+
+        expect(item1.id).toBe(1)
+        expect(item2.id).toBe(2)
+    })
+})

package/dist/databaseConnection.d.ts

@@ -1,24 +0,0 @@
-import type { IDatastoreProvider, BaseModel, BaseModelClass } from '@declaro/core';
-import type { EntityManager, FilterQuery, Reference } from "@mikro-orm/core";
-import type { RemoveReturnType, UpsertReturnType } from "./datastoreAbstract";
-export type DatabaseConnectionOptions = {
-    populate?: string[];
-    immutableFields?: string[];
-};
-export declare class DatabaseConnection<T extends BaseModel<any>> implements IDatastoreProvider<T> {
-    private repository;
-    static inject: readonly ["EntityManager", "Reference"];
-    readonly em: EntityManager;
-    private hydrator;
-    private populate;
-    private immutableFields;
-    constructor(em: EntityManager, reference: typeof Reference);
-    setup(model: BaseModelClass<T>, options: DatabaseConnectionOptions): void;
-    getAll(): Promise<void | any[]>;
-    getWhere(filter?: FilterQuery<any>): Promise<void | any[]>;
-    get(id: string | number): Promise<any>;
-    upsert<T extends BaseModel<any> | BaseModel<any>[]>(data: T): Promise<UpsertReturnType<T>>;
-    private singleUpsert;
-    remove(data: T[] | T): Promise<RemoveReturnType>;
-    private singleRemove;
-}

package/dist/datastoreAbstract.d.ts

@@ -1,37 +0,0 @@
-import type { IDatastoreProvider, BaseModel, BaseModelClass, IStore } from "@declaro/core";
-import type { FetchFunc } from '@declaro/core';
-import { TrackedStatusStore } from "./trackedStatus";
-import type { FilterQuery } from "@mikro-orm/core";
-export type TrackedPayload<T> = {
-    model: T;
-    requestId: string;
-    optimistic?: boolean;
-};
-export type UpsertReturnType<T> = T extends (infer U)[] ? U[] : T;
-export type RemoveReturnType = (number | string)[] | number | string | null;
-export declare abstract class AbstractStore<T extends BaseModel<any>> implements IStore {
-    protected connection: IDatastoreProvider<T>;
-    protected model: BaseModelClass<T>;
-    protected options?: any;
-    protected value: T[];
-    private subscribers;
-    private hydrated;
-    trackedStatus: TrackedStatusStore;
-    protected constructor(connection: IDatastoreProvider<T>, model: BaseModelClass<T>, options?: any);
-    subscribe(subscription: (value: T[]) => void): (() => void);
-    setFetch(fetch: FetchFunc): void;
-    set(value: T[]): void;
-    get(value: string | number): Promise<T>;
-    getWhere(filter?: FilterQuery<any>): Promise<T[]>;
-    getAll(): Promise<T[]>;
-    hydrate(id?: string | number, filter?: FilterQuery<any>): Promise<void>;
-    upsert(model: T | T[], optimistic?: boolean): Promise<UpsertReturnType<T>>;
-    remove(model: T | T[], optimistic?: boolean): Promise<RemoveReturnType>;
-    trackedUpsert(payload: TrackedPayload<T | T[]>): Promise<UpsertReturnType<T>>;
-    trackedRemove(payload: TrackedPayload<T | T[]>): Promise<RemoveReturnType>;
-    insertIntoStore(obj: T): void;
-    removeFromStore(obj: T): void;
-}
-export type ActionableStore = AbstractStore<BaseModel<any>> & {
-    [key: string]: (...args: any[]) => any;
-};

package/dist/declaro-data.cjs

@@ -1 +0,0 @@
-"use strict";var u=Object.defineProperty;var l=(o,e,t)=>e in o?u(o,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):o[e]=t;var n=(o,e,t)=>(l(o,typeof e!="symbol"?e+"":e,t),t);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class h{constructor(e,t){this.em=e,this.reference=t}hydrateEntity(e){const t=this.em.getMetadata().get(e.constructor.name);for(const s in e){const r=t.properties[s];if(e[s]!==void 0&&e[s]!==null&&r&&["m:1","1:1"].includes(r.reference)){const i=r.entity();e[s]=this.reference.createFromPK(i.meta.class,e[s])}}return e}}class c{constructor(e,t){n(this,"repository");n(this,"em");n(this,"hydrator");n(this,"populate");n(this,"immutableFields",[]);this.em=e,this.hydrator=new h(this.em,t)}setup(e,t){this.repository=this.em.getRepository(e),this.populate=t==null?void 0:t.populate,t!=null&&t.immutableFields&&(this.immutableFields=t.immutableFields)}getAll(){return this.repository.findAll({populate:this.populate}).catch(e=>{console.log(e)})}getWhere(e){return this.repository.find(e,{populate:this.populate}).catch(t=>{console.log(t)})}get(e){return this.repository.findOne(e,{populate:this.populate}).catch(t=>{console.log(t)})}async upsert(e){if(Array.isArray(e)){const t=[];for(const s of e){const r=await this.singleUpsert(s);t.push(r)}return t}else return await this.singleUpsert(e)}async singleUpsert(e){let t;const s=this.em.getMetadata().get(e.constructor.name),r={};return Object.keys(e).forEach(i=>{const a=s.properties[i];a&&a.reference!=="m:n"&&(r[i]=e[i])}),e.id?t=await this.em.findOneOrFail(e.constructor.name,e.id):(t=this.em.create(e.constructor.name,r),await this.em.persist(t).flush()),delete e.id,this.immutableFields.forEach(i=>{i in e&&(e[i]=t[i])}),this.em.assign(t,e),await this.em.persist(t).flush(),t}async remove(e){if(Array.isArray(e)){const t=[];for(const s of e)await this.singleRemove(s)&&t.push(s.id);return t}else return await this.singleRemove(e)?e.id:null}async singleRemove(e){try{const t=await this.em.findOneOrFail(e.constructor.name,e.id);return await this.em.remove(t).flush(),!0}catch(t){if(t.constructor.name==="NotFoundError")return!1;throw t}}}n(c,"inject",["EntityManager","Reference"]);class m{constructor(){n(this,"fetch");n(this,"model")}setup(e){this.model=e}setFetch(e){this.fetch=e}getAll(){return this.fetch(`/store/${this.model.name}/getAll`).then(e=>e.json().then(t=>t.map(s=>Object.assign(new this.model,s))))}getWhere(e){return this.fetch(`/store/${this.model.name}/getWhere/${JSON.stringify(e)}`).then(t=>t.json().then(s=>s.map(r=>Object.assign(new this.model,r))))}get(e){return this.fetch(`/store/${this.model.name}/get/${e}`).then(t=>t.json())}upsert(e){return this._callStoreMethod("upsert","POST",e)}remove(e){return this._callStoreMethod("remove","POST",e)}_callStoreMethod(e,t,s=null){let r={};return s&&(r["Content-Type"]="application/json;",r.Accept="application/json;"),this.fetch(`/store/${this.model.name}/${e}`,{method:t,body:s?JSON.stringify(s):null,headers:r}).then(async i=>{const a=await i.json();if(i.ok)return a;throw Error(a.message)})}}class f{constructor(){n(this,"value",{});n(this,"subscribers",[])}subscribe(e){return this.subscribers.push(e),e(this.value),()=>{this.subscribers=this.subscribers.filter(t=>t!==e)}}push(e){this.value={...this.value,[e.requestId]:e},this.subscribers.forEach(t=>t(this.value))}remove(e){const{[e]:t,...s}=this.value;this.value=s,this.subscribers.forEach(r=>r(this.value))}}class d{constructor(e,t,s){n(this,"value",[]);n(this,"subscribers",[]);n(this,"hydrated",!1);n(this,"trackedStatus",new f);this.connection=e,this.model=t,this.options=s,this.connection.setup(this.model,s)}subscribe(e){return this.subscribers.push(e),e(this.value),()=>{this.subscribers=this.subscribers.filter(t=>t!==e)}}setFetch(e){const t=this.connection;t.setFetch&&t.setFetch(e)}set(e){this.value=e,this.subscribers.forEach(t=>t(e))}async get(e){return await this.hydrate(e),typeof this.value>"u"?null:this.value.filter(s=>s.id==e)[0]}async getWhere(e){return await this.hydrate(null,e),this.value}async getAll(){return await this.hydrate(),this.value}async hydrate(e,t){if(!(this.hydrated&&!t)){if(t){const s=await this.connection.getWhere(t);s&&this.set(s)}else if(e){if(!t){const s=await this.connection.get(e);s&&this.set([s])}}else{const s=await this.connection.getAll();s&&this.set(s)}this.hydrated=!0}}async upsert(e,t=!1){if(Array.isArray(e)){const s=e.map(i=>Object.assign(new this.model,i));t&&s.forEach(i=>this.insertIntoStore(i));const r=await this.connection.upsert(s);return r.forEach(i=>this.insertIntoStore(i)),r}else{const s=Object.assign(new this.model,e);t&&this.insertIntoStore(s);const r=await this.connection.upsert(s);return this.insertIntoStore(r),r}}async remove(e,t=!1){if(Array.isArray(e)){const s=e.map(i=>Object.assign(new this.model,i));t&&s.forEach(i=>this.removeFromStore(i));const r=await this.connection.remove(s);return s.forEach(i=>this.removeFromStore(i)),r}else{const s=Object.assign(new this.model,e);t&&this.removeFromStore(s);const r=await this.connection.remove(s);return this.removeFromStore(s),r}}async trackedUpsert(e){try{const t=await this.upsert(e.model);return this.trackedStatus.push({requestId:e.requestId,error:!1,message:"Upserted successfully"}),t}catch(t){this.trackedStatus.push({requestId:e.requestId,error:!0,message:t.message})}}async trackedRemove(e){try{const t=await this.remove(e.model);return this.trackedStatus.push({requestId:e.requestId,error:!1,message:"Removed successfully"}),t}catch(t){this.trackedStatus.push({requestId:e.requestId,error:!0,message:t.message})}}insertIntoStore(e){this.value.some(s=>s.id===e.id)?this.set(this.value.map(s=>s.id===e.id?e:s)):this.set([...this.value,e])}removeFromStore(e){this.set(this.value.filter(t=>t.id!==e.id))}}exports.AbstractStore=d;exports.DatabaseConnection=c;exports.Hydrator=h;exports.ServerConnection=m;