Classes

ApprovalOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: ApprovalFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<ApprovalModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`ApprovalFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<ApprovalModel> -

findOne

findOne(approvalId: string): Promise<ApprovalModel | null>

Parameters:

Parameter	Type	Required	Description
`approvalId`	`string`	Yes

Returns:

Promise<ApprovalModel \| null> -

count

count(filters: ApprovalFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`ApprovalFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<ApprovalModel, CreateApprovalInput>

Returns:

MutationOperator<ApprovalModel, CreateApprovalInput> -

updateMutation

updateMutation(): MutationOperator<ApprovalModel, UpdateApprovalInput>

Returns:

MutationOperator<ApprovalModel, UpdateApprovalInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

AttributeOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: AttributeFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<AttributeModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`AttributeFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<AttributeModel> -

findOne

findOne(attributeId: string): Promise<AttributeModel | null>

Parameters:

Parameter	Type	Required	Description
`attributeId`	`string`	Yes

Returns:

Promise<AttributeModel \| null> -

count

count(filters: AttributeFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`AttributeFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<AttributeModel, CreateAttributeInput>

Returns:

MutationOperator<AttributeModel, CreateAttributeInput> -

updateMutation

updateMutation(): MutationOperator<AttributeModel, UpdateAttributeInput>

Returns:

MutationOperator<AttributeModel, UpdateAttributeInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

BusinessPlanOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: BusinessPlanFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<BusinessPlanModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`BusinessPlanFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<BusinessPlanModel> -

findOne

findOne(planId: string): Promise<BusinessPlanModel | null>

Parameters:

Parameter	Type	Required	Description
`planId`	`string`	Yes

Returns:

Promise<BusinessPlanModel \| null> -

count

count(filters: BusinessPlanFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`BusinessPlanFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<BusinessPlanModel, CreateBusinessPlanInput>

Returns:

MutationOperator<BusinessPlanModel, CreateBusinessPlanInput> -

updateMutation

updateMutation(): MutationOperator<BusinessPlanModel, UpdateBusinessPlanInput>

Returns:

MutationOperator<BusinessPlanModel, UpdateBusinessPlanInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

ClientOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: ClientFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<ClientModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`ClientFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<ClientModel> -

findOne

findOne(clientId: string): Promise<ClientModel | null>

Parameters:

Parameter	Type	Required	Description
`clientId`	`string`	Yes

Returns:

Promise<ClientModel \| null> -

count

count(filters: ClientFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`ClientFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<ClientModel, CreateClientInput>

Returns:

MutationOperator<ClientModel, CreateClientInput> -

updateMutation

updateMutation(): MutationOperator<ClientModel, UpdateClientInput>

Returns:

MutationOperator<ClientModel, UpdateClientInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

CodebaseOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: CodebaseFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<CodebaseModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`CodebaseFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<CodebaseModel> -

findOne

findOne(codebaseId: string): Promise<CodebaseModel | null>

Parameters:

Parameter	Type	Required	Description
`codebaseId`	`string`	Yes

Returns:

Promise<CodebaseModel \| null> -

count

count(filters: CodebaseFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`CodebaseFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<CodebaseModel, CreateCodebaseInput>

Returns:

MutationOperator<CodebaseModel, CreateCodebaseInput> -

updateMutation

updateMutation(): MutationOperator<CodebaseModel, UpdateCodebaseInput>

Returns:

MutationOperator<CodebaseModel, UpdateCodebaseInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

CompetitorOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: CompetitorFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<CompetitorModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`CompetitorFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<CompetitorModel> -

findOne

findOne(competitorId: string): Promise<CompetitorModel | null>

Parameters:

Parameter	Type	Required	Description
`competitorId`	`string`	Yes

Returns:

Promise<CompetitorModel \| null> -

createMutation

createMutation(): MutationOperator<CompetitorModel, CreateCompetitorInput>

Returns:

MutationOperator<CompetitorModel, CreateCompetitorInput> -

updateMutation

updateMutation(): MutationOperator<CompetitorModel, UpdateCompetitorInput>

Returns:

MutationOperator<CompetitorModel, UpdateCompetitorInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

ContactOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: ContactFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<ContactModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`ContactFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<ContactModel> -

findOne

findOne(contactId: string): Promise<ContactModel | null>

Parameters:

Parameter	Type	Required	Description
`contactId`	`string`	Yes

Returns:

Promise<ContactModel \| null> -

count

count(filters: ContactFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`ContactFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<ContactModel, CreateContactInput>

Returns:

MutationOperator<ContactModel, CreateContactInput> -

updateMutation

updateMutation(): MutationOperator<ContactModel, UpdateContactInput>

Returns:

MutationOperator<ContactModel, UpdateContactInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

ConversationOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: ConversationFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<ConversationModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`ConversationFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<ConversationModel> -

findOne

findOne(conversationId: string): Promise<ConversationModel | null>

Parameters:

Parameter	Type	Required	Description
`conversationId`	`string`	Yes

Returns:

Promise<ConversationModel \| null> -

count

count(filters: ConversationFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`ConversationFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<ConversationModel, CreateConversationInput>

Returns:

MutationOperator<ConversationModel, CreateConversationInput> -

updateMutation

updateMutation(): MutationOperator<ConversationModel, UpdateConversationInput>

Returns:

MutationOperator<ConversationModel, UpdateConversationInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

DiscussionOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: DiscussionFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<DiscussionModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`DiscussionFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<DiscussionModel> -

findOne

findOne(discussionId: string): Promise<DiscussionModel | null>

Parameters:

Parameter	Type	Required	Description
`discussionId`	`string`	Yes

Returns:

Promise<DiscussionModel \| null> -

count

count(filters: DiscussionFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`DiscussionFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<DiscussionModel, CreateDiscussionInput>

Returns:

MutationOperator<DiscussionModel, CreateDiscussionInput> -

updateMutation

updateMutation(): MutationOperator<DiscussionModel, UpdateDiscussionInput>

Returns:

MutationOperator<DiscussionModel, UpdateDiscussionInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

DocumentOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: DocumentFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<DocumentModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`DocumentFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<DocumentModel> -

findOne

findOne(documentId: string): Promise<DocumentModel | null>

Parameters:

Parameter	Type	Required	Description
`documentId`	`string`	Yes

Returns:

Promise<DocumentModel \| null> -

count

count(filters: DocumentFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`DocumentFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<DocumentModel, CreateDocumentInput>

Returns:

MutationOperator<DocumentModel, CreateDocumentInput> -

updateMutation

updateMutation(): MutationOperator<DocumentModel, UpdateDocumentInput>

Returns:

MutationOperator<DocumentModel, UpdateDocumentInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

approveMutation

approveMutation(): MutationOperator<DocumentModel, { id: string; userId: string; }>

Returns:

MutationOperator<DocumentModel, { id: string; userId: string; }> -

FinAccountOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: FinAccountFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<FinAccountModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinAccountFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<FinAccountModel> -

findOne

findOne(accountId: string): Promise<FinAccountModel | null>

Parameters:

Parameter	Type	Required	Description
`accountId`	`string`	Yes

Returns:

Promise<FinAccountModel \| null> -

count

count(filters: FinAccountFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinAccountFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<FinAccountModel, CreateFinAccountInput>

Returns:

MutationOperator<FinAccountModel, CreateFinAccountInput> -

updateMutation

updateMutation(): MutationOperator<FinAccountModel, UpdateFinAccountInput>

Returns:

MutationOperator<FinAccountModel, UpdateFinAccountInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

FinBudgetOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: FinBudgetFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<BudgetModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinBudgetFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<BudgetModel> -

findOne

findOne(budgetId: string): Promise<BudgetModel | null>

Parameters:

Parameter	Type	Required	Description
`budgetId`	`string`	Yes

Returns:

Promise<BudgetModel \| null> -

count

count(filters: FinBudgetFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinBudgetFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<BudgetModel, CreateFinBudgetInput>

Returns:

MutationOperator<BudgetModel, CreateFinBudgetInput> -

updateMutation

updateMutation(): MutationOperator<BudgetModel, UpdateFinBudgetInput>

Returns:

MutationOperator<BudgetModel, UpdateFinBudgetInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

FinCategoryOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: FinCategoryFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<FinCategoryModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinCategoryFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<FinCategoryModel> -

findOne

findOne(categoryId: string): Promise<FinCategoryModel | null>

Parameters:

Parameter	Type	Required	Description
`categoryId`	`string`	Yes

Returns:

Promise<FinCategoryModel \| null> -

count

count(filters: FinCategoryFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinCategoryFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<FinCategoryModel, CreateFinCategoryInput>

Returns:

MutationOperator<FinCategoryModel, CreateFinCategoryInput> -

updateMutation

updateMutation(): MutationOperator<FinCategoryModel, UpdateFinCategoryInput>

Returns:

MutationOperator<FinCategoryModel, UpdateFinCategoryInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

FinIncomeStatementOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: FinIncomeStatementFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<FinIncomeStatementModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinIncomeStatementFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<FinIncomeStatementModel> -

findOne

findOne(statementId: string): Promise<FinIncomeStatementModel | null>

Parameters:

Parameter	Type	Required	Description
`statementId`	`string`	Yes

Returns:

Promise<FinIncomeStatementModel \| null> -

count

count(filters: FinIncomeStatementFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinIncomeStatementFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<FinIncomeStatementModel, CreateFinIncomeStatementInput>

Returns:

MutationOperator<FinIncomeStatementModel, CreateFinIncomeStatementInput> -

updateMutation

updateMutation(): MutationOperator<FinIncomeStatementModel, UpdateFinIncomeStatementInput>

Returns:

MutationOperator<FinIncomeStatementModel, UpdateFinIncomeStatementInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

FinScheduledTransactionOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: FinScheduledTransactionFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<FinScheduledTransactionModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinScheduledTransactionFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<FinScheduledTransactionModel> -

findOne

findOne(scheduledTransactionId: string): Promise<FinScheduledTransactionModel | null>

Parameters:

Parameter	Type	Required	Description
`scheduledTransactionId`	`string`	Yes

Returns:

Promise<FinScheduledTransactionModel \| null> -

count

count(filters: FinScheduledTransactionFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinScheduledTransactionFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<FinScheduledTransactionModel, CreateFinScheduledTransactionInput>

Returns:

MutationOperator<FinScheduledTransactionModel, CreateFinScheduledTransactionInput> -

updateMutation

updateMutation(): MutationOperator<FinScheduledTransactionModel, UpdateFinScheduledTransactionInput>

Returns:

MutationOperator<FinScheduledTransactionModel, UpdateFinScheduledTransactionInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

FinTransactionOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: FinTransactionFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<FinTransactionModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinTransactionFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<FinTransactionModel> -

findOne

findOne(transactionId: string): Promise<FinTransactionModel | null>

Parameters:

Parameter	Type	Required	Description
`transactionId`	`string`	Yes

Returns:

Promise<FinTransactionModel \| null> -

count

count(filters: FinTransactionFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`FinTransactionFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<FinTransactionModel, CreateFinTransactionInput>

Returns:

MutationOperator<FinTransactionModel, CreateFinTransactionInput> -

updateMutation

updateMutation(): MutationOperator<FinTransactionModel, UpdateFinTransactionInput>

Returns:

MutationOperator<FinTransactionModel, UpdateFinTransactionInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

FlowOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: FlowFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<FlowModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`FlowFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<FlowModel> -

findOne

findOne(flowId: string): Promise<FlowModel | null>

Parameters:

Parameter	Type	Required	Description
`flowId`	`string`	Yes

Returns:

Promise<FlowModel \| null> -

count

count(filters: FlowFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`FlowFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<FlowModel, CreateFlowInput>

Returns:

MutationOperator<FlowModel, CreateFlowInput> -

updateMutation

updateMutation(): MutationOperator<FlowModel, UpdateFlowInput>

Returns:

MutationOperator<FlowModel, UpdateFlowInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

GoalOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: GoalFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<GoalModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`GoalFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<GoalModel> -

findOne

findOne(goalId: string): Promise<GoalModel | null>

Parameters:

Parameter	Type	Required	Description
`goalId`	`string`	Yes

Returns:

Promise<GoalModel \| null> -

count

count(filters: GoalFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`GoalFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<GoalModel, CreateGoalInput>

Returns:

MutationOperator<GoalModel, CreateGoalInput> -

updateMutation

updateMutation(): MutationOperator<GoalModel, UpdateGoalInput>

Returns:

MutationOperator<GoalModel, UpdateGoalInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

InitiativeOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: InitiativeFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<InitiativeModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`InitiativeFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<InitiativeModel> -

findOne

findOne(initiativeId: string): Promise<InitiativeModel | null>

Parameters:

Parameter	Type	Required	Description
`initiativeId`	`string`	Yes

Returns:

Promise<InitiativeModel \| null> -

count

count(filters: InitiativeFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`InitiativeFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<InitiativeModel, CreateInitiativeInput>

Returns:

MutationOperator<InitiativeModel, CreateInitiativeInput> -

updateMutation

updateMutation(): MutationOperator<InitiativeModel, UpdateInitiativeInput>

Returns:

MutationOperator<InitiativeModel, UpdateInitiativeInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

MarketAnalysisOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: MarketAnalysisFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<MarketAnalysisModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`MarketAnalysisFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<MarketAnalysisModel> -

findOne

findOne(analysisId: string): Promise<MarketAnalysisModel | null>

Parameters:

Parameter	Type	Required	Description
`analysisId`	`string`	Yes

Returns:

Promise<MarketAnalysisModel \| null> -

createMutation

createMutation(): MutationOperator<MarketAnalysisModel, CreateMarketAnalysisInput>

Returns:

MutationOperator<MarketAnalysisModel, CreateMarketAnalysisInput> -

updateMutation

updateMutation(): MutationOperator<MarketAnalysisModel, UpdateMarketAnalysisInput>

Returns:

MutationOperator<MarketAnalysisModel, UpdateMarketAnalysisInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

MessageOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: MessageFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<MessageModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`MessageFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<MessageModel> -

findOne

findOne(messageId: string): Promise<MessageModel | null>

Parameters:

Parameter	Type	Required	Description
`messageId`	`string`	Yes

Returns:

Promise<MessageModel \| null> -

count

count(filters: MessageFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`MessageFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<MessageModel, CreateMessageInput>

Returns:

MutationOperator<MessageModel, CreateMessageInput> -

updateMutation

updateMutation(): MutationOperator<MessageModel, UpdateMessageInput>

Returns:

MutationOperator<MessageModel, UpdateMessageInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

MilestoneOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: MilestoneFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<MilestoneModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`MilestoneFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<MilestoneModel> -

findOne

findOne(milestoneId: string): Promise<MilestoneModel | null>

Parameters:

Parameter	Type	Required	Description
`milestoneId`	`string`	Yes

Returns:

Promise<MilestoneModel \| null> -

count

count(filters: MilestoneFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`MilestoneFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<MilestoneModel, CreateMilestoneInput>

Returns:

MutationOperator<MilestoneModel, CreateMilestoneInput> -

updateMutation

updateMutation(): MutationOperator<MilestoneModel, UpdateMilestoneInput>

Returns:

MutationOperator<MilestoneModel, UpdateMilestoneInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

completeMutation

completeMutation(): MutationOperator<MilestoneModel, string>

Returns:

MutationOperator<MilestoneModel, string> -

OpportunityOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: OpportunityFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<OpportunityModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`OpportunityFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<OpportunityModel> -

findOne

findOne(opportunityId: string): Promise<OpportunityModel | null>

Parameters:

Parameter	Type	Required	Description
`opportunityId`	`string`	Yes

Returns:

Promise<OpportunityModel \| null> -

count

count(filters: OpportunityFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`OpportunityFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<OpportunityModel, CreateOpportunityInput>

Returns:

MutationOperator<OpportunityModel, CreateOpportunityInput> -

updateMutation

updateMutation(): MutationOperator<OpportunityModel, UpdateOpportunityInput>

Returns:

MutationOperator<OpportunityModel, UpdateOpportunityInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

OrgOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: OrgFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<OrgModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`OrgFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<OrgModel> -

findOne

findOne(orgId: string): Promise<OrgModel | null>

Parameters:

Parameter	Type	Required	Description
`orgId`	`string`	Yes

Returns:

Promise<OrgModel \| null> -

count

count(filters: OrgFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`OrgFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<OrgModel, CreateOrgInput>

Returns:

MutationOperator<OrgModel, CreateOrgInput> -

updateMutation

updateMutation(): MutationOperator<OrgModel, UpdateOrgInput>

Returns:

MutationOperator<OrgModel, UpdateOrgInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

ProcessExecutionOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: ProcessExecutionFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<ProcessExecutionModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProcessExecutionFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<ProcessExecutionModel> -

findOne

findOne(executionId: string): Promise<ProcessExecutionModel | null>

Parameters:

Parameter	Type	Required	Description
`executionId`	`string`	Yes

Returns:

Promise<ProcessExecutionModel \| null> -

findByCorrelationId

findByCorrelationId(correlationId: string): Promise<ProcessExecutionModel[]>

Parameters:

Parameter	Type	Required	Description
`correlationId`	`string`	Yes

Returns:

Promise<ProcessExecutionModel[]> -

count

count(filters: ProcessExecutionFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProcessExecutionFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<ProcessExecutionModel, CreateProcessExecutionInput>

Returns:

MutationOperator<ProcessExecutionModel, CreateProcessExecutionInput> -

updateMutation

updateMutation(): MutationOperator<ProcessExecutionModel, UpdateProcessExecutionInput>

Returns:

MutationOperator<ProcessExecutionModel, UpdateProcessExecutionInput> -

startMutation

startMutation(): MutationOperator<ProcessExecutionModel, { id: string; currentStepId: string; }>

Returns:

MutationOperator<ProcessExecutionModel, { id: string; currentStepId: string; }> -

completeMutation

completeMutation(): MutationOperator<ProcessExecutionModel, { id: string; outputs?: Record<string, unknown>; }>

Returns:

MutationOperator<ProcessExecutionModel, { id: string; outputs?: Record<string, unknown>; }> -

failMutation

failMutation(): MutationOperator<ProcessExecutionModel, { id: string; error: ProcessExecutionModel["error"]; }>

Returns:

MutationOperator<ProcessExecutionModel, { id: string; error: ProcessExecutionModel["error"]; }> -

pauseMutation

pauseMutation(): MutationOperator<ProcessExecutionModel, { id: string; resumeAt?: string; }>

Returns:

MutationOperator<ProcessExecutionModel, { id: string; resumeAt?: string; }> -

resumeMutation

resumeMutation(): MutationOperator<ProcessExecutionModel, string>

Returns:

MutationOperator<ProcessExecutionModel, string> -

cancelMutation

cancelMutation(): MutationOperator<ProcessExecutionModel, string>

Returns:

MutationOperator<ProcessExecutionModel, string> -

recordStepMutation

recordStepMutation(): MutationOperator<ProcessExecutionModel, RecordStepExecutionInput>

Returns:

MutationOperator<ProcessExecutionModel, RecordStepExecutionInput> -

updateProgressMutation

updateProgressMutation(): MutationOperator<ProcessExecutionModel, { id: string; progress: number; }>

Returns:

MutationOperator<ProcessExecutionModel, { id: string; progress: number; }> -

retryMutation

retryMutation(): MutationOperator<ProcessExecutionModel, string>

Returns:

MutationOperator<ProcessExecutionModel, string> -

archiveMutation

archiveMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

ProcessOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: ProcessFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<ProcessModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProcessFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<ProcessModel> -

findOne

findOne(processId: string): Promise<ProcessModel | null>

Parameters:

Parameter	Type	Required	Description
`processId`	`string`	Yes

Returns:

Promise<ProcessModel \| null> -

findByName

findByName(orgId: string, workspaceId: string, name: string): Promise<ProcessModel | null>

Parameters:

Parameter	Type	Required
`orgId`	`string`	Yes
`workspaceId`	`string`	Yes
`name`	`string`	Yes

Returns:

Promise<ProcessModel \| null> -

count

count(filters: ProcessFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProcessFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<ProcessModel, CreateProcessInput>

Returns:

MutationOperator<ProcessModel, CreateProcessInput> -

updateMutation

updateMutation(): MutationOperator<ProcessModel, UpdateProcessInput>

Returns:

MutationOperator<ProcessModel, UpdateProcessInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

publishMutation

publishMutation(): MutationOperator<ProcessModel, string>

Returns:

MutationOperator<ProcessModel, string> -

deprecateMutation

deprecateMutation(): MutationOperator<ProcessModel, { id: string; reason?: string; replacedBy?: string; }>

Returns:

MutationOperator<ProcessModel, { id: string; reason?: string; replacedBy?: string; }> -

addStepMutation

addStepMutation(): MutationOperator<ProcessModel, { processId: string; stepId: string; position?: number; }>

Returns:

MutationOperator<ProcessModel, { processId: string; stepId: string; position?: number; }> -

removeStepMutation

removeStepMutation(): MutationOperator<ProcessModel, { processId: string; stepId: string; }>

Returns:

MutationOperator<ProcessModel, { processId: string; stepId: string; }> -

ProcessStepOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: ProcessStepFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<ProcessStepModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProcessStepFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<ProcessStepModel> -

findOne

findOne(stepId: string): Promise<ProcessStepModel | null>

Parameters:

Parameter	Type	Required	Description
`stepId`	`string`	Yes

Returns:

Promise<ProcessStepModel \| null> -

findByProcess

findByProcess(processId: string): Promise<ProcessStepModel[]>

Parameters:

Parameter	Type	Required	Description
`processId`	`string`	Yes

Returns:

Promise<ProcessStepModel[]> -

count

count(filters: ProcessStepFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProcessStepFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<ProcessStepModel, CreateProcessStepInput>

Returns:

MutationOperator<ProcessStepModel, CreateProcessStepInput> -

updateMutation

updateMutation(): MutationOperator<ProcessStepModel, UpdateProcessStepInput>

Returns:

MutationOperator<ProcessStepModel, UpdateProcessStepInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

enableMutation

enableMutation(): MutationOperator<ProcessStepModel, string>

Returns:

MutationOperator<ProcessStepModel, string> -

disableMutation

disableMutation(): MutationOperator<ProcessStepModel, string>

Returns:

MutationOperator<ProcessStepModel, string> -

updatePositionMutation

updatePositionMutation(): MutationOperator<ProcessStepModel, { id: string; position: StepPosition; }>

Returns:

MutationOperator<ProcessStepModel, { id: string; position: StepPosition; }> -

reorderMutation

reorderMutation(): MutationOperator<ProcessStepModel[], { processId: string; stepIds: string[]; }>

Returns:

MutationOperator<ProcessStepModel[], { processId: string; stepIds: string[]; }> -

ProductOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: ProductFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<ProductModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProductFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<ProductModel> -

findOne

findOne(productId: string): Promise<ProductModel | null>

Parameters:

Parameter	Type	Required	Description
`productId`	`string`	Yes

Returns:

Promise<ProductModel \| null> -

count

count(filters: ProductFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProductFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<ProductModel, CreateProductInput>

Returns:

MutationOperator<ProductModel, CreateProductInput> -

updateMutation

updateMutation(): MutationOperator<ProductModel, UpdateProductInput>

Returns:

MutationOperator<ProductModel, UpdateProductInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

ProjectOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: ProjectFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<ProjectModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProjectFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<ProjectModel> -

findOne

findOne(projectId: string): Promise<ProjectModel | null>

Parameters:

Parameter	Type	Required	Description
`projectId`	`string`	Yes

Returns:

Promise<ProjectModel \| null> -

count

count(filters: ProjectFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`ProjectFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<ProjectModel, CreateProjectInput>

Returns:

MutationOperator<ProjectModel, CreateProjectInput> -

updateMutation

updateMutation(): MutationOperator<ProjectModel, UpdateProjectInput>

Returns:

MutationOperator<ProjectModel, UpdateProjectInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

completeMutation

completeMutation(): MutationOperator<ProjectModel, string>

Returns:

MutationOperator<ProjectModel, string> -

RoadmapOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: RoadmapFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<RoadmapModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`RoadmapFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<RoadmapModel> -

findOne

findOne(roadmapId: string): Promise<RoadmapModel | null>

Parameters:

Parameter	Type	Required	Description
`roadmapId`	`string`	Yes

Returns:

Promise<RoadmapModel \| null> -

count

count(filters: RoadmapFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`RoadmapFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<RoadmapModel, CreateRoadmapInput>

Returns:

MutationOperator<RoadmapModel, CreateRoadmapInput> -

updateMutation

updateMutation(): MutationOperator<RoadmapModel, UpdateRoadmapInput>

Returns:

MutationOperator<RoadmapModel, UpdateRoadmapInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

SessionOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: SessionFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<SessionModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`SessionFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<SessionModel> -

findOne

findOne(sessionId: string): Promise<SessionModel | null>

Parameters:

Parameter	Type	Required	Description
`sessionId`	`string`	Yes

Returns:

Promise<SessionModel \| null> -

count

count(filters: SessionFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`SessionFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<SessionModel, CreateSessionInput>

Returns:

MutationOperator<SessionModel, CreateSessionInput> -

updateMutation

updateMutation(): MutationOperator<SessionModel, UpdateSessionInput>

Returns:

MutationOperator<SessionModel, UpdateSessionInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

TaskOperator

Framework-agnostic task operations

Provides query and mutation operators for tasks that work in any environment. Use this directly in Node.js scripts or wrap with framework hooks (React, Vue, etc.).

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

Create a query operator for tasks

Returns a QueryOperator that can be used imperatively (exec) or reactively (observable).

query(filters: TaskFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<TaskModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`TaskFilters`	Yes	- Task filters to apply
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No	- Optional query options (sort, limit, skip)

Returns:

QueryOperator<TaskModel> - QueryOperator instance for tasks

findOne

Find a single task by ID

findOne(taskId: string): Promise<TaskModel | null>

Parameters:

Parameter	Type	Required	Description
`taskId`	`string`	Yes	- Task ID to find

Returns:

Promise<TaskModel \| null> - Promise resolving to task or null if not found

count

Count tasks matching the given filters

count(filters: TaskFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`TaskFilters`	Yes	- Task filters to apply

Returns:

Promise<number> - Promise resolving to count of matching tasks

createMutation

Create a mutation operator for creating tasks

createMutation(): MutationOperator<TaskModel, CreateTaskInput>

Returns:

MutationOperator<TaskModel, CreateTaskInput> - MutationOperator for task creation

updateMutation

Create a mutation operator for updating tasks

updateMutation(): MutationOperator<TaskModel, UpdateTaskInput>

Returns:

MutationOperator<TaskModel, UpdateTaskInput> - MutationOperator for task updates

deleteMutation

Create a mutation operator for deleting tasks (soft delete)

Marks task as archived rather than physically deleting it.

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> - MutationOperator for task deletion

completeMutation

Create a mutation operator for completing tasks

Sets task status to 'Complete' and marks as completed.

completeMutation(): MutationOperator<TaskModel, string>

Returns:

MutationOperator<TaskModel, string> - MutationOperator for task completion

Examples:

// Node.js script usage
const taskOps = new TaskOperator(db);
const query = taskOps.query({ orgId: 'org_123', status: 'In Progress' });
const tasks = await query.exec();

// Create task
const mutation = taskOps.createMutation();
const newTask = await mutation.execute({
  title: 'New Task',
  description: 'Task description',
  orgId: 'org_123',
  userId: 'user_456',
  projectId: 'proj_789',
  milestoneId: 'mile_101'
});

TemplateOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: TemplateFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<TemplateModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`TemplateFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<TemplateModel> -

findOne

findOne(templateId: string): Promise<TemplateModel | null>

Parameters:

Parameter	Type	Required	Description
`templateId`	`string`	Yes

Returns:

Promise<TemplateModel \| null> -

count

count(filters: TemplateFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`TemplateFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<TemplateModel, CreateTemplateInput>

Returns:

MutationOperator<TemplateModel, CreateTemplateInput> -

updateMutation

updateMutation(): MutationOperator<TemplateModel, UpdateTemplateInput>

Returns:

MutationOperator<TemplateModel, UpdateTemplateInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

TimeEntryOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: TimeEntryFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<TimeEntryModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`TimeEntryFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<TimeEntryModel> -

findOne

findOne(timeEntryId: string): Promise<TimeEntryModel | null>

Parameters:

Parameter	Type	Required	Description
`timeEntryId`	`string`	Yes

Returns:

Promise<TimeEntryModel \| null> -

count

count(filters: TimeEntryFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`TimeEntryFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<TimeEntryModel, CreateTimeEntryInput>

Returns:

MutationOperator<TimeEntryModel, CreateTimeEntryInput> -

updateMutation

updateMutation(): MutationOperator<TimeEntryModel, UpdateTimeEntryInput>

Returns:

MutationOperator<TimeEntryModel, UpdateTimeEntryInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

UserOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: UserFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<UserModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`UserFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<UserModel> -

findOne

findOne(userId: string): Promise<UserModel | null>

Parameters:

Parameter	Type	Required	Description
`userId`	`string`	Yes

Returns:

Promise<UserModel \| null> -

count

count(filters: UserFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`UserFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<UserModel, CreateUserInput>

Returns:

MutationOperator<UserModel, CreateUserInput> -

updateMutation

updateMutation(): MutationOperator<UserModel, UpdateUserInput>

Returns:

MutationOperator<UserModel, UpdateUserInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

VariablesOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: VariablesFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<VariablesModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`VariablesFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<VariablesModel> -

findOne

findOne(variableId: string): Promise<VariablesModel | null>

Parameters:

Parameter	Type	Required	Description
`variableId`	`string`	Yes

Returns:

Promise<VariablesModel \| null> -

count

count(filters: VariablesFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`VariablesFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<VariablesModel, CreateVariablesInput>

Returns:

MutationOperator<VariablesModel, CreateVariablesInput> -

updateMutation

updateMutation(): MutationOperator<VariablesModel, UpdateVariablesInput>

Returns:

MutationOperator<VariablesModel, UpdateVariablesInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

WorkspaceOperator

Constructor

constructor(db: RxDatabase)

Parameters:

Parameter	Type	Required	Description
`db`	`RxDatabase`	Yes

Methods

query

query(filters: WorkspaceFilters, options?: { sort?: string; limit?: number; skip?: number; } | undefined): QueryOperator<WorkspaceModel>

Parameters:

Parameter	Type	Required	Description
`filters`	`WorkspaceFilters`	Yes
`options`	`{ sort?: string; limit?: number; skip?: number; } \| undefined`	No

Returns:

QueryOperator<WorkspaceModel> -

findOne

findOne(workspaceId: string): Promise<WorkspaceModel | null>

Parameters:

Parameter	Type	Required	Description
`workspaceId`	`string`	Yes

Returns:

Promise<WorkspaceModel \| null> -

count

count(filters: WorkspaceFilters): Promise<number>

Parameters:

Parameter	Type	Required	Description
`filters`	`WorkspaceFilters`	Yes

Returns:

Promise<number> -

createMutation

createMutation(): MutationOperator<WorkspaceModel, CreateWorkspaceInput>

Returns:

MutationOperator<WorkspaceModel, CreateWorkspaceInput> -

updateMutation

updateMutation(): MutationOperator<WorkspaceModel, UpdateWorkspaceInput>

Returns:

MutationOperator<WorkspaceModel, UpdateWorkspaceInput> -

deleteMutation

deleteMutation(): MutationOperator<void, string>

Returns:

MutationOperator<void, string> -

MutationOperator

Framework-agnostic mutation operator

Wraps RxDB write operations with state management and callbacks. Works in any environment (Node.js, Browser, React Native, Electron).

Constructor

constructor(collection: RxCollection, options: MutationOptions<TData, TVariables>)

Parameters:

Parameter	Type	Required	Description
`collection`	`RxCollection`	Yes
`options`	`MutationOptions<TData, TVariables>`	Yes

Methods

execute

Execute mutation imperatively

Performs the mutation, updates state, and invokes callbacks. Returns Promise for imperative usage in scripts and CLI tools.

execute(variables: TVariables): Promise<TData>

Parameters:

Parameter	Type	Required	Description
`variables`	`TVariables`	Yes	- Input variables for the mutation

Returns:

Promise<TData> - Promise resolving to mutation result data

reset

Reset mutation state to initial values

reset(): void

destroy

Cleanup and complete observables

Call this when the mutation operator is no longer needed.

destroy(): void

Examples:

// Create mutation operator
const createTask = new MutationOperator(collection, {
  mutationFn: async (col, data) => {
    await col.insert(data);
    return data;
  },
  onSuccess: (data) => console.log('Created:', data.id)
});

// Execute imperatively
const task = await createTask.execute({ title: 'New Task' });

// Or subscribe reactively
createTask.state$.subscribe(state => {
  if (state.isLoading) console.log('Saving...');
  if (state.data) console.log('Saved!');
});

QueryOperator

Framework-agnostic query operator

Wraps RxDB queries with reactive observables that work in any environment. Provides both imperative (exec) and reactive (observable) APIs.

Constructor

constructor(collection: RxCollection, options: QueryOptions<T>)

Parameters:

Parameter	Type	Required	Description
`collection`	`RxCollection`	Yes
`options`	`QueryOptions<T>`	Yes

Methods

exec

Execute query imperatively and return results as Promise

Use in Node.js scripts, CLI tools, and other imperative contexts.

exec(): Promise<T[]>

Returns:

Promise<T[]> - Promise resolving to array of documents

refetch

Refetch query results imperatively

refetch(): Promise<T[]>

Returns:

Promise<T[]> - Promise resolving to current query results

destroy

Cleanup subscriptions and complete observables

Call this when the query is no longer needed to prevent memory leaks.

destroy(): void

Examples:

// Imperative usage (Node.js, CLI)
const query = new QueryOperator(collection, { selector: { status: 'active' } });
const results = await query.exec();

// Reactive usage (UI frameworks)
query.observable.subscribe(result => {
  console.log('Data updated:', result.data);
});