Skip to main content
QuikDB SDK provides a robust set of TypeScript type definitions to ensure type safety and enhance developer experience. Below are the available types and their usages:

​
Field

Description: Represents a field within a schema. Usage: 
interface Field {
  name: string;
  fieldType: 'Text' | 'Int' | 'Bool';
  unique: boolean;
}
Example: 
const fields: Field[] = [
  { name: 'username', unique: false, fieldType: 'Text' },
  { name: 'age', unique: false, fieldType: 'Int' },
  { name: 'email', unique: true, fieldType: 'Text' },
];

​
CreateSchemaArgs

Description: Arguments required to create a new schema. Usage: 
type CreateSchemaArgs = [string, Field[], string[]];
Example: 
const createSchemaArgs: CreateSchemaArgs = ['UserSchema', fields, ['email']];

​
ResultBool

Description: Represents the result of operations that return a boolean status. Usage: 
interface ResultBool {
  ok?: boolean;
  err?: string;
}
Example: 
const result: ResultBool = await quikdb.callCanisterMethod(CanisterMethod.CreateSchema, args);
if (result.ok) {
  console.log('Schema created successfully.');
} else {
  console.error(`Error: ${result.err}`);
}

​
GetSchemaArgs

Description: Arguments required to retrieve a specific schema. Usage: 
type GetSchemaArgs = [string];
Example: 
const getSchemaArgs: GetSchemaArgs = ['UserSchema'];
const schema: Schema[] = await quikdb.callCanisterMethod(CanisterMethod.GetSchema, getSchemaArgs);

​
Schema

Description: Represents the structure of a schema. Usage: 
interface Schema {
  schemaName: string;
  fields: Field[];
  indexes: string[];
}
Example: 
const schema: Schema = {
  schemaName: 'UserSchema',
  fields: [...],
  indexes: ['email'],
};

​
DeleteSchemaArgs

Description: Arguments required to delete a specific schema. Usage: 
type DeleteSchemaArgs = [string];
Example: 
const deleteSchemaArgs: DeleteSchemaArgs = ['UserSchema'];
const deleteResult: ResultBool = await quikdb.callCanisterMethod(CanisterMethod.DeleteSchema, deleteSchemaArgs);

​
ListSchemasArgs

Description: Arguments required to list all schemas. Usage: 
type ListSchemasArgs = [];
Example: 
const listSchemasArgs: ListSchemasArgs = [];
const schemas: string[] = await quikdb.callCanisterMethod(CanisterMethod.ListSchemas, listSchemasArgs);

​
CreateRecordDataArgs

Description: Arguments required to create a new record within a schema. Usage: 
type CreateRecordDataArgs = [string, DBRecord];
Example: 
const record: DBRecord = {
  id: 'record1',
  fields: [
    ['username', 'testuser'],
    ['age', '30'],
    ['email', 'testuser@example.com'],
  ],
};
const createRecordArgs: CreateRecordDataArgs = ['UserSchema', record];
const insertResult: ResultBool = await quikdb.callCanisterMethod(CanisterMethod.CreateRecordData, createRecordArgs);

​
GetRecordArgs

Description: Arguments required to retrieve a specific record. Usage: 
type GetRecordArgs = [string, string];
Example: 
const getRecordArgs: GetRecordArgs = ['UserSchema', 'record1'];
const recordResult: ResultString = await quikdb.callCanisterMethod(CanisterMethod.GetRecord, getRecordArgs);

​
GetAllRecordsArgs

Description: Arguments required to retrieve all records within a schema. Usage: 
type GetAllRecordsArgs = [string];
Example: 
const getAllRecordsArgs: GetAllRecordsArgs = ['UserSchema'];
const allRecords: ResultRecords = await quikdb.callCanisterMethod(CanisterMethod.GetAllRecords, getAllRecordsArgs);

​
UpdateDataArgs

Description: Arguments required to update specific fields of a record. Usage: 
type UpdateDataArgs = [string, string, [string, string][]];
Example: 
const updatedFields: [string, string][] = [['age', '31']];
const updateDataArgs: UpdateDataArgs = ['UserSchema', 'record1', updatedFields];
const updateResult: ResultBool = await quikdb.callCanisterMethod(CanisterMethod.UpdateData, updateDataArgs);

​
DeleteDataArgs

Description: Arguments required to delete a specific record. Usage: 
type DeleteDataArgs = [string, string];
Example: 
const deleteDataArgs: DeleteDataArgs = ['UserSchema', 'record1'];
const deleteResult: ResultBool = await quikdb.callCanisterMethod(CanisterMethod.DeleteRecord, deleteDataArgs);

​
GetOwnerArgs

Description: Arguments required to retrieve the owner principal. Usage: 
type GetOwnerArgs = [];
Example: 
const getOwnerArgs: GetOwnerArgs = [];
const owner: Principal = await quikdb.callCanisterMethod(CanisterMethod.GetOwner, getOwnerArgs);

​
InitOwnerArgs

Description: Arguments required to initialize the owner. Usage: 
type InitOwnerArgs = [];
Example: 
const initOwnerArgs: InitOwnerArgs = [];
const initOwnerResult: ResultBool = await quikdb.callCanisterMethod(CanisterMethod.InitOwner, initOwnerArgs);

​
GetMetricsArgs

Description: Arguments required to retrieve metrics for a schema. Usage: 
type GetMetricsArgs = [string];
Example: 
const getMetricsArgs: GetMetricsArgs = ['UserSchema'];
const metrics: ResultTuple = await quikdb.callCanisterMethod(CanisterMethod.GetMetrics, getMetricsArgs);
if (metrics.ok) {
  const [count, size] = metrics.ok;
  console.log(`Record Count: ${count}, Total Size: ${size}`);
} else {
  console.error(`Error: ${metrics.err}`);
}

​
GetRecordSizesArgs

Description: Arguments required to retrieve the sizes of records within a schema. Usage: 
type GetRecordSizesArgs = [string];
Example: 
const getRecordSizesArgs: GetRecordSizesArgs = ['UserSchema'];
const recordSizes: ResultStrings = await quikdb.callCanisterMethod(CanisterMethod.GetRecordSizes, getRecordSizesArgs);
if (recordSizes.ok) {
  recordSizes.ok.forEach(size => console.log(`Record Size: ${size}`));
} else {
  console.error(`Error: ${recordSizes.err}`);
}

​
QueryByIndexArgs

Description: Arguments required to query records by an indexed field. Usage: 
type QueryByIndexArgs = [string, string, string];
Example: 
const queryByIndexArgs: QueryByIndexArgs = ['UserSchema', 'username', 'testuser'];
const queryResult: ResultRecords = await quikdb.callCanisterMethod(CanisterMethod.SearchByIndex, queryByIndexArgs);

​
SearchByIndexArgs

Description: Arguments required to search records by an indexed field. Usage: 
type SearchByIndexArgs = [string, string, string];
Example: 
const searchByIndexArgs: SearchByIndexArgs = ['UserSchema', 'status', 'active'];
const searchResult: ResultRecords = await quikdb.callCanisterMethod(CanisterMethod.SearchByIndex, searchByIndexArgs);

​
SearchByMultipleFieldsArgs

Description: Arguments required to search records by multiple fields. Usage: 
type SearchByMultipleFieldsArgs = [string, [string, string][]];
Example: 
const searchByMultipleFieldsArgs: SearchByMultipleFieldsArgs = [
  'UserSchema',
  [
    ['email', 'user2@example.com'],
    ['status', 'inactive'],
  ],
];
const searchMultipleResult: ResultRecords = await quikdb.callCanisterMethod(
  CanisterMethod.SearchByMultipleFields,
  searchByMultipleFieldsArgs
);

​
DBRecord

Description: Represents a database record within a schema. Usage: 
interface DBRecord {
  id: string;
  fields: [string, string][];
}
Example: 
const record: DBRecord = {
  id: 'record1',
  fields: [
    ['username', 'testuser'],
    ['age', '30'],
    ['email', 'testuser@example.com'],
  ],
};

​
NoOfSchemaArgs

Description: Arguments required to retrieve the number of schemas. Usage: 
type NoOfSchemaArgs = [];
Example: 
const noOfSchemaArgs: NoOfSchemaArgs = [];
const noOfSchemas: number | ResultBool = await quikdb.callCanisterMethod(CanisterMethod.NoOfSchema, noOfSchemaArgs);

​
ResultRecords

Description: Represents the result containing multiple records. Usage: 
interface ResultRecords {
  ok?: DBRecord[];
  err?: string;
}
Example: 
const allRecords: ResultRecords = await quikdb.callCanisterMethod(CanisterMethod.GetAllRecords, getAllRecordsArgs);
if (allRecords.ok) {
  allRecords.ok.forEach(record => console.log(record));
} else {
  console.error(`Error: ${allRecords.err}`);
}

​
ResultString

Description: Represents the result containing a single string. Usage: 
interface ResultString {
  ok?: string;
  err?: string;
}
Example: 
const recordResult: ResultString = await quikdb.callCanisterMethod(CanisterMethod.GetRecord, getRecordArgs);
if (recordResult.ok) {
  console.log('Record Details:', recordResult.ok);
} else {
  console.error(`Error: ${recordResult.err}`);
}

​
ResultStrings

Description: Represents the result containing multiple strings. Usage: 
interface ResultStrings {
  ok?: string[];
  err?: string;
}
Example: 
const recordSizes: ResultStrings = await quikdb.callCanisterMethod(CanisterMethod.GetRecordSizes, getRecordSizesArgs);
if (recordSizes.ok) {
  recordSizes.ok.forEach(size => console.log(`Record Size: ${size}`));
} else {
  console.error(`Error: ${recordSizes.err}`);
}

​
ResultTuple

Description: Represents the result containing a tuple of values. Usage: 
type ResultTuple = {
  ok?: [bigint, bigint];
  err?: string;
};
Example: 
const metrics: ResultTuple = await quikdb.callCanisterMethod(CanisterMethod.GetMetrics, getMetricsArgs);
if (metrics.ok) {
  const [count, size] = metrics.ok;
  console.log(`Record Count: ${count}, Total Size: ${size}`);
} else {
  console.error(`Error: ${metrics.err}`);
}