1194 lines
29 KiB
TypeScript
1194 lines
29 KiB
TypeScript
import type { RequestOptions } from "https";
|
|
|
|
export type NSQLITE_DatabaseFullName = string;
|
|
|
|
export const UsersOmitedFields = [
|
|
"password",
|
|
"social_id",
|
|
"verification_status",
|
|
"date_created",
|
|
"date_created_code",
|
|
"date_created_timestamp",
|
|
"date_updated",
|
|
"date_updated_code",
|
|
"date_updated_timestamp",
|
|
] as const;
|
|
|
|
export interface NSQLITE_DatabaseSchemaType {
|
|
id?: string | number;
|
|
dbName?: string;
|
|
dbSlug?: string;
|
|
dbFullName?: string;
|
|
dbDescription?: string;
|
|
dbImage?: string;
|
|
tables: NSQLITE_TableSchemaType[];
|
|
childrenDatabases?: NSQLITE_ChildrenDatabaseObject[];
|
|
childDatabase?: boolean;
|
|
childDatabaseDbId?: string | number;
|
|
updateData?: boolean;
|
|
collation?: (typeof MariaDBCollations)[number];
|
|
}
|
|
|
|
export interface NSQLITE_ChildrenDatabaseObject {
|
|
dbId?: string | number;
|
|
}
|
|
|
|
export const MariaDBCollations = [
|
|
"utf8mb4_bin",
|
|
"utf8mb4_unicode_520_ci",
|
|
] as const;
|
|
|
|
export interface NSQLITE_TableSchemaType {
|
|
id?: string | number;
|
|
tableName: string;
|
|
tableDescription?: string;
|
|
fields: NSQLITE_FieldSchemaType[];
|
|
indexes?: NSQLITE_IndexSchemaType[];
|
|
uniqueConstraints?: NSQLITE_UniqueConstraintSchemaType[];
|
|
childrenTables?: NSQLITE_ChildrenTablesType[];
|
|
/**
|
|
* Whether this is a child table
|
|
*/
|
|
childTable?: boolean;
|
|
updateData?: boolean;
|
|
/**
|
|
* ID of the parent table
|
|
*/
|
|
childTableId?: string | number;
|
|
/**
|
|
* ID of the parent table
|
|
*/
|
|
parentTableId?: string | number;
|
|
/**
|
|
* ID of the Database of parent table
|
|
*/
|
|
parentTableDbId?: string | number;
|
|
/**
|
|
* Name of the Database of parent table
|
|
*/
|
|
parentTableDbName?: string;
|
|
/**
|
|
* Name of the parent table
|
|
*/
|
|
parentTableName?: string;
|
|
tableNameOld?: string;
|
|
/**
|
|
* ID of the Database of parent table
|
|
*/
|
|
childTableDbId?: string | number;
|
|
collation?: (typeof MariaDBCollations)[number];
|
|
isVector?: boolean;
|
|
vectorType?: string;
|
|
}
|
|
|
|
export interface NSQLITE_ChildrenTablesType {
|
|
tableId?: string | number;
|
|
dbId?: string | number;
|
|
}
|
|
|
|
export const TextFieldTypesArray = [
|
|
{ title: "Plain Text", value: "plain" },
|
|
{ title: "Rich Text", value: "richText" },
|
|
{ title: "Markdown", value: "markdown" },
|
|
{ title: "JSON", value: "json" },
|
|
{ title: "YAML", value: "yaml" },
|
|
{ title: "HTML", value: "html" },
|
|
{ title: "CSS", value: "css" },
|
|
{ title: "Javascript", value: "javascript" },
|
|
{ title: "Shell", value: "shell" },
|
|
{ title: "Code", value: "code" },
|
|
] as const;
|
|
|
|
export const NSQLITE_DATATYPES = [
|
|
{ value: "TEXT" },
|
|
{ value: "INTEGER" },
|
|
] as const;
|
|
|
|
export type NSQLITE_FieldSchemaType = {
|
|
id?: number | string;
|
|
fieldName?: string;
|
|
fieldDescription?: string;
|
|
originName?: string;
|
|
updatedField?: boolean;
|
|
dataType: (typeof NSQLITE_DATATYPES)[number]["value"];
|
|
nullValue?: boolean;
|
|
notNullValue?: boolean;
|
|
primaryKey?: boolean;
|
|
encrypted?: boolean;
|
|
autoIncrement?: boolean;
|
|
defaultValue?: string | number;
|
|
defaultValueLiteral?: string;
|
|
foreignKey?: NSQLITE_ForeignKeyType;
|
|
defaultField?: boolean;
|
|
plainText?: boolean;
|
|
unique?: boolean;
|
|
pattern?: string;
|
|
patternFlags?: string;
|
|
onUpdate?: string;
|
|
onUpdateLiteral?: string;
|
|
onDelete?: string;
|
|
onDeleteLiteral?: string;
|
|
cssFiles?: string[];
|
|
integerLength?: string | number;
|
|
decimals?: string | number;
|
|
code?: boolean;
|
|
options?: (string | number)[];
|
|
isVector?: boolean;
|
|
vectorSize?: number;
|
|
/**
|
|
* ### Adds a `+` prefix to colums
|
|
* In sqlite-vec, the + prefix is a specialized syntax for Virtual Table Columns. It essentially tells the database: "Keep this data associated with the vector, but don't try to index it for math."
|
|
Here is the breakdown of why they matter and how they work:
|
|
1. Performance Separation
|
|
In a standard table, adding a massive TEXT column (like a 2,000-word article) slows down full-table scans. In a vec0 virtual table, columns prefixed with + are stored in a separate internal side-car table.
|
|
The Vector Index: Stays lean and fast for "Nearest Neighbor" math.
|
|
The Content: Is only fetched after the vector search identifies the winning rows.
|
|
2. The "No Join" Convenience
|
|
Normally, you would store vectors in one table and the actual text content in another, linking them with a FOREIGN KEY.
|
|
Without + columns: You must JOIN two tables to get the text after finding the vector.
|
|
With + columns: You can SELECT content directly from the virtual table. It handles the "join" logic internally, making your code cleaner.
|
|
3. Syntax Example
|
|
When defining your schema, the + is only used in the CREATE statement. When querying or inserting, you treat it like a normal name.
|
|
```sql
|
|
-- SCHEMA DEFINITION
|
|
CREATE VIRTUAL TABLE documents USING vec0(
|
|
embedding float, -- The vector (indexed)
|
|
+title TEXT, -- Side-car metadata (not indexed)
|
|
+raw_body TEXT -- Side-car "heavy" data (not indexed)
|
|
);
|
|
|
|
-- INSERTING (Notice: No '+' here)
|
|
INSERT INTO documents(embedding, title, raw_body)
|
|
VALUES (vec_f32(?), 'Node Docs', 'Node is a fast JavaScript runtime...');
|
|
|
|
-- QUERYING (Notice: No '+' here)
|
|
SELECT title, raw_body
|
|
FROM documents
|
|
WHERE embedding MATCH ? AND k = 1;
|
|
```
|
|
*/
|
|
sideCar?: boolean;
|
|
} & {
|
|
[key in (typeof TextFieldTypesArray)[number]["value"]]?: boolean;
|
|
};
|
|
|
|
export interface NSQLITE_ForeignKeyType {
|
|
foreignKeyName?: string;
|
|
destinationTableName?: string;
|
|
destinationTableColumnName?: string;
|
|
destinationTableColumnType?: string;
|
|
cascadeDelete?: boolean;
|
|
cascadeUpdate?: boolean;
|
|
}
|
|
|
|
export interface NSQLITE_IndexSchemaType {
|
|
id?: string | number;
|
|
indexName?: string;
|
|
indexType?: (typeof IndexTypes)[number];
|
|
indexTableFields?: NSQLITE_IndexTableFieldType[];
|
|
alias?: string;
|
|
newTempIndex?: boolean;
|
|
}
|
|
|
|
export interface NSQLITE_UniqueConstraintSchemaType {
|
|
id?: string | number;
|
|
constraintName?: string;
|
|
alias?: string;
|
|
constraintTableFields?: NSQLITE_UniqueConstraintFieldType[];
|
|
}
|
|
|
|
export interface NSQLITE_UniqueConstraintFieldType {
|
|
value: string;
|
|
}
|
|
|
|
export interface NSQLITE_IndexTableFieldType {
|
|
value: string;
|
|
dataType: string;
|
|
}
|
|
|
|
export interface NSQLITE_MYSQL_SHOW_INDEXES_Type {
|
|
Key_name: string;
|
|
Table: string;
|
|
Column_name: string;
|
|
Collation: string;
|
|
Index_type: string;
|
|
Cardinality: string;
|
|
Index_comment: string;
|
|
Comment: string;
|
|
}
|
|
|
|
export interface NSQLITE_MYSQL_SHOW_COLUMNS_Type {
|
|
Field: string;
|
|
Type: string;
|
|
Null: string;
|
|
Key: string;
|
|
Default: string;
|
|
Extra: string;
|
|
}
|
|
|
|
export interface NSQLITE_MARIADB_SHOW_INDEXES_TYPE {
|
|
Table: string;
|
|
Non_unique: 0 | 1;
|
|
Key_name: string;
|
|
Seq_in_index: number;
|
|
Column_name: string;
|
|
Collation: string;
|
|
Cardinality: number;
|
|
Sub_part?: string;
|
|
Packed?: string;
|
|
Index_type?: "BTREE";
|
|
Comment?: string;
|
|
Index_comment?: string;
|
|
Ignored?: "YES" | "NO";
|
|
}
|
|
|
|
export interface NSQLITE_MYSQL_FOREIGN_KEYS_Type {
|
|
CONSTRAINT_NAME: string;
|
|
CONSTRAINT_SCHEMA: string;
|
|
TABLE_NAME: string;
|
|
}
|
|
|
|
export interface NSQLITE_MYSQL_user_databases_Type {
|
|
id: number;
|
|
user_id: number;
|
|
db_full_name: string;
|
|
db_name: string;
|
|
db_slug: string;
|
|
db_image: string;
|
|
db_description: string;
|
|
active_clone: number;
|
|
active_data: 0 | 1;
|
|
active_clone_parent_db: string;
|
|
remote_connected?: number;
|
|
remote_db_full_name?: string;
|
|
remote_connection_host?: string;
|
|
remote_connection_key?: string;
|
|
remote_connection_type?: string;
|
|
user_priviledge?: string;
|
|
date_created?: string;
|
|
image_thumbnail?: string;
|
|
first_name?: string;
|
|
last_name?: string;
|
|
email?: string;
|
|
}
|
|
|
|
export type ImageInputFileToBase64FunctionReturn = {
|
|
imageBase64?: string;
|
|
imageBase64Full?: string;
|
|
imageName?: string;
|
|
imageSize?: number;
|
|
};
|
|
|
|
export interface GetReqQueryObject {
|
|
db: string;
|
|
query: string;
|
|
queryValues?: string;
|
|
tableName?: string;
|
|
debug?: boolean;
|
|
}
|
|
|
|
export type DATASQUIREL_LoggedInUser = {
|
|
id: number;
|
|
uuid?: string;
|
|
first_name: string;
|
|
last_name: string;
|
|
email: string;
|
|
phone?: string;
|
|
user_type?: string;
|
|
username?: string;
|
|
image?: string;
|
|
image_thumbnail?: string;
|
|
social_login?: number;
|
|
social_platform?: string;
|
|
social_id?: string;
|
|
verification_status?: number;
|
|
csrf_k: string;
|
|
logged_in_status: boolean;
|
|
date: number;
|
|
} & {
|
|
[key: string]: any;
|
|
};
|
|
|
|
export interface AuthenticatedUser {
|
|
success: boolean;
|
|
payload: DATASQUIREL_LoggedInUser | null;
|
|
msg?: string;
|
|
userId?: number;
|
|
cookieNames?: any;
|
|
}
|
|
|
|
export interface SuccessUserObject {
|
|
id: number;
|
|
first_name: string;
|
|
last_name: string;
|
|
email: string;
|
|
}
|
|
|
|
export interface AddUserFunctionReturn {
|
|
success: boolean;
|
|
payload?: SuccessUserObject | null;
|
|
msg?: string;
|
|
sqlResult?: any;
|
|
}
|
|
|
|
export interface GoogleIdentityPromptNotification {
|
|
getMomentType: () => string;
|
|
getDismissedReason: () => string;
|
|
getNotDisplayedReason: () => string;
|
|
getSkippedReason: () => string;
|
|
isDismissedMoment: () => boolean;
|
|
isDisplayMoment: () => boolean;
|
|
isDisplayed: () => boolean;
|
|
isNotDisplayed: () => boolean;
|
|
isSkippedMoment: () => boolean;
|
|
}
|
|
|
|
export type UserDataPayload = {
|
|
first_name: string;
|
|
last_name: string;
|
|
email: string;
|
|
password?: string;
|
|
username?: string;
|
|
} & {
|
|
[key: string]: any;
|
|
};
|
|
|
|
export interface GetUserFunctionReturn {
|
|
success: boolean;
|
|
payload: {
|
|
id: number;
|
|
first_name: string;
|
|
last_name: string;
|
|
username: string;
|
|
email: string;
|
|
phone: string;
|
|
social_id: [string];
|
|
image: string;
|
|
image_thumbnail: string;
|
|
verification_status: [number];
|
|
} | null;
|
|
}
|
|
|
|
export interface ReauthUserFunctionReturn {
|
|
success: boolean;
|
|
payload: DATASQUIREL_LoggedInUser | null;
|
|
msg?: string;
|
|
userId?: number;
|
|
token?: string;
|
|
}
|
|
|
|
export interface UpdateUserFunctionReturn {
|
|
success: boolean;
|
|
payload?: Object[] | string;
|
|
}
|
|
|
|
export interface GetReturn<R extends any = any> {
|
|
success: boolean;
|
|
payload?: R;
|
|
msg?: string;
|
|
error?: string;
|
|
schema?: NSQLITE_TableSchemaType;
|
|
finalQuery?: string;
|
|
}
|
|
|
|
export interface GetSchemaRequestQuery {
|
|
database?: string;
|
|
table?: string;
|
|
field?: string;
|
|
user_id?: string | number;
|
|
env?: { [k: string]: string };
|
|
}
|
|
|
|
export interface GetSchemaAPICredentialsParam {
|
|
key: string;
|
|
}
|
|
|
|
export type GetSchemaAPIParam = GetSchemaRequestQuery &
|
|
GetSchemaAPICredentialsParam;
|
|
|
|
export interface PostReturn {
|
|
success: boolean;
|
|
payload?: Object[] | string | PostInsertReturn;
|
|
msg?: string;
|
|
error?: any;
|
|
schema?: NSQLITE_TableSchemaType;
|
|
}
|
|
|
|
export interface PostDataPayload {
|
|
action: "insert" | "update" | "delete";
|
|
table: string;
|
|
data?: object;
|
|
identifierColumnName?: string;
|
|
identifierValue?: string;
|
|
duplicateColumnName?: string;
|
|
duplicateColumnValue?: string;
|
|
update?: boolean;
|
|
}
|
|
|
|
export interface LocalPostReturn {
|
|
success: boolean;
|
|
payload?: any;
|
|
msg?: string;
|
|
error?: string;
|
|
}
|
|
|
|
export interface LocalPostQueryObject {
|
|
query: string | PostDataPayload;
|
|
tableName?: string;
|
|
queryValues?: string[];
|
|
}
|
|
|
|
export interface PostInsertReturn {
|
|
fieldCount?: number;
|
|
affectedRows?: number;
|
|
insertId?: number;
|
|
serverStatus?: number;
|
|
warningCount?: number;
|
|
message?: string;
|
|
protocol41?: boolean;
|
|
changedRows?: number;
|
|
error?: string;
|
|
}
|
|
|
|
export type UserType = DATASQUIREL_LoggedInUser & {
|
|
isSuperUser?: boolean;
|
|
staticHost?: string;
|
|
appHost?: string;
|
|
appName?: string;
|
|
};
|
|
|
|
export interface ApiKeyDef {
|
|
name: string;
|
|
scope: string;
|
|
date_created: string;
|
|
apiKeyPayload: string;
|
|
}
|
|
|
|
export interface MetricsType {
|
|
dbCount: number;
|
|
tablesCount: number;
|
|
mediaCount: number;
|
|
apiKeysCount: number;
|
|
}
|
|
|
|
export interface MYSQL_mariadb_users_table_def {
|
|
id?: number;
|
|
user_id?: number;
|
|
username?: string;
|
|
host?: string;
|
|
password?: string;
|
|
primary?: number;
|
|
grants?: string;
|
|
date_created?: string;
|
|
date_created_code?: number;
|
|
date_created_timestamp?: string;
|
|
date_updated?: string;
|
|
date_updated_code?: number;
|
|
date_updated_timestamp?: string;
|
|
}
|
|
|
|
export interface MariaDBUserCredType {
|
|
mariadb_user?: string;
|
|
mariadb_host?: string;
|
|
mariadb_pass?: string;
|
|
}
|
|
|
|
export const ServerQueryOperators = ["AND", "OR"] as const;
|
|
export const ServerQueryEqualities = [
|
|
"EQUAL",
|
|
"LIKE",
|
|
"LIKE_RAW",
|
|
"LIKE_LOWER",
|
|
"LIKE_LOWER_RAW",
|
|
"NOT LIKE",
|
|
"NOT LIKE_RAW",
|
|
"NOT_LIKE_LOWER",
|
|
"NOT_LIKE_LOWER_RAW",
|
|
"NOT EQUAL",
|
|
"REGEXP",
|
|
"FULLTEXT",
|
|
"IN",
|
|
"NOT IN",
|
|
"BETWEEN",
|
|
"NOT BETWEEN",
|
|
"IS NULL",
|
|
"IS NOT NULL",
|
|
"EXISTS",
|
|
"NOT EXISTS",
|
|
"GREATER THAN",
|
|
"GREATER THAN OR EQUAL",
|
|
"LESS THAN",
|
|
"LESS THAN OR EQUAL",
|
|
"MATCH",
|
|
"MATCH_BOOLEAN",
|
|
] as const;
|
|
|
|
export type ServerQueryParam<
|
|
T extends { [k: string]: any } = { [k: string]: any },
|
|
K extends string = string,
|
|
> = {
|
|
selectFields?: (keyof T | TableSelectFieldsObject<T>)[];
|
|
omitFields?: (keyof T)[];
|
|
query?: ServerQueryQueryObject<T>;
|
|
limit?: number;
|
|
page?: number;
|
|
offset?: number;
|
|
order?: ServerQueryParamOrder<T> | ServerQueryParamOrder<T>[];
|
|
searchOperator?: (typeof ServerQueryOperators)[number];
|
|
searchEquality?: (typeof ServerQueryEqualities)[number];
|
|
addUserId?: {
|
|
fieldName: keyof T;
|
|
};
|
|
join?: (
|
|
| ServerQueryParamsJoin<K>
|
|
| ServerQueryParamsJoin<K>[]
|
|
| undefined
|
|
)[];
|
|
group?:
|
|
| keyof T
|
|
| ServerQueryParamGroupBy<T>
|
|
| (keyof T | ServerQueryParamGroupBy<T>)[];
|
|
countSubQueries?: ServerQueryParamsCount[];
|
|
fullTextSearch?: ServerQueryParamFullTextSearch<T>;
|
|
[key: string]: any;
|
|
};
|
|
|
|
export type ServerQueryParamGroupBy<
|
|
T extends { [k: string]: any } = { [k: string]: any },
|
|
> = {
|
|
field: keyof T;
|
|
table?: string;
|
|
};
|
|
|
|
export type ServerQueryParamOrder<
|
|
T extends { [k: string]: any } = { [k: string]: any },
|
|
> = {
|
|
field: keyof T;
|
|
strategy: "ASC" | "DESC";
|
|
};
|
|
|
|
export type ServerQueryParamFullTextSearch<
|
|
T extends { [k: string]: any } = { [k: string]: any },
|
|
> = {
|
|
fields: (keyof T)[];
|
|
searchTerm: string;
|
|
/** Field Name to user to Rank the Score of Search Results */
|
|
scoreAlias: string;
|
|
};
|
|
|
|
export type ServerQueryParamsCount = {
|
|
table: string;
|
|
/** Alias for the Table From which the count is fetched */
|
|
table_alias?: string;
|
|
srcTrgMap: {
|
|
src: string;
|
|
trg: string | ServerQueryParamsCountSrcTrgMap;
|
|
}[];
|
|
alias: string;
|
|
};
|
|
|
|
export type ServerQueryParamsCountSrcTrgMap = {
|
|
table: string;
|
|
field: string;
|
|
};
|
|
|
|
export type TableSelectFieldsObject<
|
|
T extends { [k: string]: any } = { [k: string]: any },
|
|
> = {
|
|
fieldName: keyof T;
|
|
alias?: string;
|
|
};
|
|
|
|
export type ServerQueryValuesObject = {
|
|
value?: string | number;
|
|
equality?: (typeof ServerQueryEqualities)[number];
|
|
tableName?: string;
|
|
fieldName?: string;
|
|
};
|
|
|
|
export type ServerQueryObjectValue =
|
|
| string
|
|
| (string | ServerQueryValuesObject | undefined | null)
|
|
| (string | ServerQueryValuesObject | undefined | null)[];
|
|
|
|
export type ServerQueryObject<
|
|
T extends object = { [key: string]: any },
|
|
K extends string = string,
|
|
> = {
|
|
value?: ServerQueryObjectValue;
|
|
nullValue?: boolean;
|
|
notNullValue?: boolean;
|
|
operator?: (typeof ServerQueryOperators)[number];
|
|
equality?: (typeof ServerQueryEqualities)[number];
|
|
tableName?: K;
|
|
/**
|
|
* This will replace the top level field name if
|
|
* provided
|
|
*/
|
|
fieldName?: string;
|
|
__query?: {
|
|
[key in keyof T]: Omit<ServerQueryObject<T>, "__query">;
|
|
};
|
|
vector?: boolean;
|
|
/**
|
|
* ### The Function to be used to generate the vector.
|
|
* Eg. `vec_f32`. This will come out as `vec_f32(?)`
|
|
* instead of just `?`
|
|
*/
|
|
vectorFunction?: string;
|
|
};
|
|
|
|
export type ServerQueryQueryObject<
|
|
T extends object = { [key: string]: any },
|
|
K extends string = string,
|
|
> = {
|
|
[key in keyof T]: ServerQueryObject<T, K>;
|
|
};
|
|
|
|
export type FetchDataParams = {
|
|
path: string;
|
|
method?: (typeof DataCrudRequestMethods)[number];
|
|
body?: object | string;
|
|
query?: AuthFetchQuery;
|
|
tableName?: string;
|
|
};
|
|
|
|
export type AuthFetchQuery = ServerQueryParam & {
|
|
[key: string]: any;
|
|
};
|
|
|
|
export type ServerQueryParamsJoin<
|
|
Table extends string = string,
|
|
Field extends object = { [key: string]: any },
|
|
> = {
|
|
joinType: "INNER JOIN" | "JOIN" | "LEFT JOIN" | "RIGHT JOIN";
|
|
alias?: string;
|
|
tableName: Table;
|
|
match?:
|
|
| ServerQueryParamsJoinMatchObject<Field>
|
|
| ServerQueryParamsJoinMatchObject<Field>[];
|
|
selectFields?: (
|
|
| keyof Field
|
|
| {
|
|
field: keyof Field;
|
|
alias?: string;
|
|
count?: boolean;
|
|
}
|
|
)[];
|
|
omitFields?: (
|
|
| keyof Field
|
|
| {
|
|
field: keyof Field;
|
|
alias?: string;
|
|
count?: boolean;
|
|
}
|
|
)[];
|
|
operator?: (typeof ServerQueryOperators)[number];
|
|
};
|
|
|
|
export type ServerQueryParamsJoinMatchObject<
|
|
Field extends object = { [key: string]: any },
|
|
> = {
|
|
/** Field name from the **Root Table** */
|
|
source?: string | ServerQueryParamsJoinMatchSourceTargetObject;
|
|
/** Field name from the **Join Table** */
|
|
target?: keyof Field | ServerQueryParamsJoinMatchSourceTargetObject;
|
|
/** A literal value: No source and target Needed! */
|
|
targetLiteral?: string | number;
|
|
__batch?: {
|
|
matches: Omit<ServerQueryParamsJoinMatchObject<Field>, "__batch">[];
|
|
operator: "AND" | "OR";
|
|
};
|
|
};
|
|
|
|
export type ServerQueryParamsJoinMatchSourceTargetObject = {
|
|
tableName: string;
|
|
fieldName: string;
|
|
};
|
|
|
|
export type ApiConnectBody = {
|
|
url: string;
|
|
key: string;
|
|
database: NSQLITE_MYSQL_user_databases_Type;
|
|
dbSchema: NSQLITE_DatabaseSchemaType;
|
|
type: "pull" | "push";
|
|
user_id?: string | number;
|
|
};
|
|
|
|
export type SuUserType = {
|
|
email: string;
|
|
password: string;
|
|
authKey: string;
|
|
logged_in_status: boolean;
|
|
date: number;
|
|
};
|
|
|
|
export type MariadbRemoteServerObject = {
|
|
host: string;
|
|
port: number;
|
|
primary?: boolean;
|
|
loadBalanced?: boolean;
|
|
users?: MariadbRemoteServerUserObject[];
|
|
};
|
|
|
|
export type MariadbRemoteServerUserObject = {
|
|
name: string;
|
|
password: string;
|
|
host: string;
|
|
};
|
|
|
|
export type APILoginFunctionReturn = {
|
|
success: boolean;
|
|
msg?: string;
|
|
payload?: DATASQUIREL_LoggedInUser | null;
|
|
userId?: number | string;
|
|
key?: string;
|
|
token?: string;
|
|
csrf?: string;
|
|
cookieNames?: any;
|
|
};
|
|
|
|
export type APICreateUserFunctionParams = {
|
|
encryptionKey?: string;
|
|
payload: any;
|
|
database: string;
|
|
dsqlUserID?: string | number;
|
|
verify?: boolean;
|
|
};
|
|
|
|
export type APICreateUserFunction = (
|
|
params: APICreateUserFunctionParams,
|
|
) => Promise<AddUserFunctionReturn>;
|
|
|
|
export type HandleSocialDbFunctionReturn = {
|
|
success: boolean;
|
|
user?: DATASQUIREL_LoggedInUser | null;
|
|
msg?: string;
|
|
social_id?: string | number;
|
|
social_platform?: string;
|
|
payload?: any;
|
|
alert?: boolean;
|
|
newUser?: any;
|
|
error?: any;
|
|
} | null;
|
|
|
|
export type CookieObject = {
|
|
name: string;
|
|
value: string;
|
|
domain?: string;
|
|
path?: string;
|
|
expires?: Date;
|
|
maxAge?: number;
|
|
secure?: boolean;
|
|
httpOnly?: boolean;
|
|
sameSite?: "Strict" | "Lax" | "None";
|
|
priority?: "Low" | "Medium" | "High";
|
|
};
|
|
|
|
export type HttpRequestParams<
|
|
ReqObj extends { [k: string]: any } = { [k: string]: any },
|
|
> = RequestOptions & {
|
|
scheme?: "http" | "https";
|
|
body?: ReqObj;
|
|
query?: ReqObj;
|
|
urlEncodedFormBody?: boolean;
|
|
};
|
|
|
|
export type HttpRequestFunction<
|
|
ReqObj extends { [k: string]: any } = { [k: string]: any },
|
|
ResObj extends { [k: string]: any } = { [k: string]: any },
|
|
> = (param: HttpRequestParams<ReqObj>) => Promise<HttpFunctionResponse<ResObj>>;
|
|
|
|
export type HttpFunctionResponse<
|
|
ResObj extends { [k: string]: any } = { [k: string]: any },
|
|
> = {
|
|
status: number;
|
|
data?: ResObj;
|
|
error?: string;
|
|
str?: string;
|
|
requestedPath?: string;
|
|
};
|
|
|
|
export type ApiGetQueryObject<
|
|
T extends { [k: string]: any } = { [k: string]: any },
|
|
> = {
|
|
query: ServerQueryParam<T>;
|
|
table: string;
|
|
dbFullName?: string;
|
|
};
|
|
|
|
export const DataCrudRequestMethods = [
|
|
"GET",
|
|
"POST",
|
|
"PUT",
|
|
"PATCH",
|
|
"DELETE",
|
|
"OPTIONS",
|
|
] as const;
|
|
|
|
export const DataCrudRequestMethodsLowerCase = [
|
|
"get",
|
|
"post",
|
|
"put",
|
|
"patch",
|
|
"delete",
|
|
"options",
|
|
] as const;
|
|
|
|
export type DsqlMethodCrudParam<
|
|
T extends { [key: string]: any } = { [key: string]: any },
|
|
> = {
|
|
method: (typeof DataCrudRequestMethods)[number];
|
|
body?: T;
|
|
query?: DsqlCrudQueryObject<T>;
|
|
tableName: string;
|
|
addUser?: {
|
|
field: keyof T;
|
|
};
|
|
user?: DATASQUIREL_LoggedInUser;
|
|
extraData?: T;
|
|
transformData?: DsqlCrudTransformDataFunction<T>;
|
|
transformQuery?: DsqlCrudTransformQueryFunction<T>;
|
|
existingData?: T;
|
|
targetId?: string | number;
|
|
sanitize?: ({ data, batchData }: { data?: T; batchData?: T[] }) => T | T[];
|
|
debug?: boolean;
|
|
};
|
|
|
|
export type DsqlCrudTransformDataFunction<
|
|
T extends { [key: string]: any } = { [key: string]: any },
|
|
> = (params: {
|
|
data: T;
|
|
user?: DATASQUIREL_LoggedInUser;
|
|
existingData?: T;
|
|
reqMethod: (typeof DataCrudRequestMethods)[number];
|
|
}) => Promise<T>;
|
|
|
|
export type DsqlCrudTransformQueryFunction<
|
|
T extends { [key: string]: any } = { [key: string]: any },
|
|
> = (params: {
|
|
query: DsqlCrudQueryObject<T>;
|
|
user?: DATASQUIREL_LoggedInUser;
|
|
reqMethod: (typeof DataCrudRequestMethods)[number];
|
|
}) => Promise<DsqlCrudQueryObject<T>>;
|
|
|
|
export const DsqlCrudActions = ["insert", "update", "delete", "get"] as const;
|
|
|
|
export type DsqlCrudQueryObject<
|
|
T extends { [key: string]: any } = { [key: string]: any },
|
|
K extends string = string,
|
|
> = ServerQueryParam<T, K> & {
|
|
query?: ServerQueryQueryObject<T, K>;
|
|
};
|
|
|
|
export type SQLDeleteGeneratorParams<
|
|
T extends { [key: string]: any } = { [key: string]: any },
|
|
> = {
|
|
tableName: string;
|
|
deleteKeyValues?: SQLDeleteData<T>[];
|
|
deleteKeyValuesOperator?: "AND" | "OR";
|
|
dbFullName?: string;
|
|
data?: any;
|
|
};
|
|
|
|
export type SQLDeleteData<
|
|
T extends { [key: string]: any } = { [key: string]: any },
|
|
> = {
|
|
key: keyof T;
|
|
value: string | number | null | undefined;
|
|
operator?: (typeof ServerQueryEqualities)[number];
|
|
};
|
|
|
|
export type DsqlCrudParamWhereClause = {
|
|
clause: string;
|
|
params?: string[];
|
|
};
|
|
|
|
export type ErrorCallback = (title: string, error: Error, data?: any) => void;
|
|
|
|
export interface MariaDBUser {
|
|
Host?: string;
|
|
User?: string;
|
|
Password?: string;
|
|
Select_priv?: string;
|
|
Insert_priv?: string;
|
|
Update_priv?: string;
|
|
Delete_priv?: string;
|
|
Create_priv?: string;
|
|
Drop_priv?: string;
|
|
Reload_priv?: string;
|
|
Shutdown_priv?: string;
|
|
Process_priv?: string;
|
|
File_priv?: string;
|
|
Grant_priv?: string;
|
|
References_priv?: string;
|
|
Index_priv?: string;
|
|
Alter_priv?: string;
|
|
Show_db_priv?: string;
|
|
Super_priv?: string;
|
|
Create_tmp_table_priv?: string;
|
|
Lock_tables_priv?: string;
|
|
Execute_priv?: string;
|
|
Repl_slave_priv?: string;
|
|
Repl_client_priv?: string;
|
|
Create_view_priv?: string;
|
|
Show_view_priv?: string;
|
|
Create_routine_priv?: string;
|
|
Alter_routine_priv?: string;
|
|
Create_user_priv?: string;
|
|
Event_priv?: string;
|
|
Trigger_priv?: string;
|
|
Create_tablespace_priv?: string;
|
|
Delete_history_priv?: string;
|
|
ssl_type?: string;
|
|
ssl_cipher?: string;
|
|
x509_issuer?: string;
|
|
x509_subject?: string;
|
|
max_questions?: number;
|
|
max_updates?: number;
|
|
max_connections?: number;
|
|
max_user_connections?: number;
|
|
plugin?: string;
|
|
authentication_string?: string;
|
|
password_expired?: string;
|
|
is_role?: string;
|
|
default_role?: string;
|
|
max_statement_time?: number;
|
|
}
|
|
|
|
export const QueryFields = [
|
|
"duplicate",
|
|
"user_id",
|
|
"delegated_user_id",
|
|
"db_id",
|
|
"table_id",
|
|
"db_slug",
|
|
] as const;
|
|
|
|
export type LocalFolderType = {
|
|
name: string;
|
|
isPrivate: boolean;
|
|
};
|
|
|
|
export type ResponseQueryObject = {
|
|
sql?: string;
|
|
params?: (string | number)[];
|
|
};
|
|
|
|
export type APIResponseObject<
|
|
T extends { [k: string]: any } = { [k: string]: any },
|
|
> = {
|
|
success: boolean;
|
|
payload?: T[] | null;
|
|
singleRes?: T | null;
|
|
stringRes?: string | null;
|
|
numberRes?: number | null;
|
|
postInsertReturn?: PostInsertReturn | null;
|
|
payloadBase64?: string;
|
|
payloadThumbnailBase64?: string;
|
|
payloadURL?: string;
|
|
payloadThumbnailURL?: string;
|
|
error?: any;
|
|
msg?: string;
|
|
queryObject?: ResponseQueryObject;
|
|
countQueryObject?: ResponseQueryObject;
|
|
status?: number;
|
|
count?: number;
|
|
errors?: NSQLITEErrorObject[];
|
|
debug?: any;
|
|
batchPayload?: any[][] | null;
|
|
errorData?: any;
|
|
token?: string;
|
|
csrf?: string;
|
|
cookieNames?: any;
|
|
key?: string;
|
|
userId?: string | number;
|
|
code?: string;
|
|
createdAt?: number;
|
|
email?: string;
|
|
requestOptions?: RequestOptions;
|
|
logoutUser?: boolean;
|
|
redirect?: string;
|
|
};
|
|
|
|
/**
|
|
* # Docker Compose Types
|
|
*/
|
|
export type DockerCompose = {
|
|
services: DockerComposeServicesType;
|
|
networks: DockerComposeNetworks;
|
|
name: string;
|
|
};
|
|
|
|
export const DockerComposeServices = [
|
|
"setup",
|
|
"cron",
|
|
"reverse-proxy",
|
|
"webapp",
|
|
"websocket",
|
|
"static",
|
|
"db",
|
|
"maxscale",
|
|
"post-db-setup",
|
|
"web-app-post-db-setup",
|
|
"post-replica-db-setup",
|
|
"db-replica-1",
|
|
"db-replica-2",
|
|
"db-cron",
|
|
"web-app-post-db-setup",
|
|
] as const;
|
|
|
|
export type DockerComposeServicesType = {
|
|
[key in (typeof DockerComposeServices)[number]]: DockerComposeServiceWithBuildObject;
|
|
};
|
|
|
|
export type DockerComposeNetworks = {
|
|
[k: string]: {
|
|
driver?: "bridge";
|
|
ipam?: {
|
|
config: DockerComposeNetworkConfigObject[];
|
|
};
|
|
external?: boolean;
|
|
};
|
|
};
|
|
|
|
export type DockerComposeNetworkConfigObject = {
|
|
subnet: string;
|
|
gateway: string;
|
|
};
|
|
|
|
export type DockerComposeServiceWithBuildObject = {
|
|
build: DockerComposeServicesBuildObject;
|
|
env_file: string;
|
|
container_name: string;
|
|
hostname: string;
|
|
volumes: string[];
|
|
environment: string[];
|
|
ports?: string[];
|
|
networks?: DockerComposeServiceNetworkObject;
|
|
restart?: string;
|
|
depends_on?: {
|
|
[k: string]: {
|
|
condition: string;
|
|
};
|
|
};
|
|
user?: string;
|
|
};
|
|
|
|
export type DockerComposeServiceWithImage = Omit<
|
|
DockerComposeServiceWithBuildObject,
|
|
"build"
|
|
> & {
|
|
image: string;
|
|
};
|
|
|
|
export type DockerComposeServicesBuildObject = {
|
|
context: string;
|
|
dockerfile: string;
|
|
};
|
|
|
|
export type DockerComposeServiceNetworkObject = {
|
|
[k: string]: {
|
|
ipv4_address: string;
|
|
};
|
|
};
|
|
|
|
export type ClonedTableInfo = {
|
|
dbId?: string | number;
|
|
tableId?: string | number;
|
|
keepUpdated?: boolean;
|
|
keepDataUpdated?: boolean;
|
|
};
|
|
|
|
export type DefaultEntryType = {
|
|
id?: number;
|
|
uuid?: string;
|
|
date_created?: string;
|
|
date_created_code?: number;
|
|
date_created_timestamp?: string;
|
|
date_updated?: string;
|
|
date_updated_code?: number;
|
|
date_updated_timestamp?: string;
|
|
} & {
|
|
[k: string]: string | number | null;
|
|
};
|
|
|
|
export const IndexTypes = ["regular", "full_text", "vector"] as const;
|
|
|
|
export type NSQLITEErrorObject = {
|
|
sql?: string;
|
|
sqlValues?: any[];
|
|
error?: string;
|
|
};
|
|
|
|
export interface SQLInsertGenReturn {
|
|
query: string;
|
|
values: (string | number)[];
|
|
}
|
|
|
|
export type SQLInsertGenDataFn = () => {
|
|
placeholder: string;
|
|
value: string | number | Float32Array<ArrayBuffer>;
|
|
};
|
|
|
|
export type SQLInsertGenDataType = {
|
|
[k: string]: string | number | SQLInsertGenDataFn | undefined | null;
|
|
};
|
|
|
|
export type SQLInsertGenParams = {
|
|
data: SQLInsertGenDataType[];
|
|
tableName: string;
|
|
dbFullName?: string;
|
|
};
|
|
|
|
export type NSQLiteConfig = {
|
|
db_name: string;
|
|
/**
|
|
* The Name of the Database Schema File. Eg `db_schema.ts`. This is
|
|
* relative to `db_dir`, or root dir if `db_dir` is not provided
|
|
*/
|
|
db_schema_file_name: string;
|
|
/**
|
|
* The Directory for backups. Relative to db_dir.
|
|
*/
|
|
db_backup_dir?: string;
|
|
max_backups?: number;
|
|
/**
|
|
* The Root Directory for the DB file and schema
|
|
*/
|
|
db_dir?: string;
|
|
/**
|
|
* The File Path relative to the root(working) directory for the type
|
|
* definition export. Example `db_types.ts` or `types/db_types.ts`
|
|
*/
|
|
typedef_file_path?: string;
|
|
};
|
|
|
|
export type NSQLiteConfigReturn = {
|
|
config: NSQLiteConfig;
|
|
dbSchema: NSQLITE_DatabaseSchemaType;
|
|
};
|
|
|
|
export const DefaultFields: NSQLITE_FieldSchemaType[] = [
|
|
{
|
|
fieldName: "id",
|
|
dataType: "INTEGER",
|
|
primaryKey: true,
|
|
autoIncrement: true,
|
|
notNullValue: true,
|
|
fieldDescription: "The unique identifier of the record.",
|
|
},
|
|
{
|
|
fieldName: "created_at",
|
|
dataType: "INTEGER",
|
|
fieldDescription:
|
|
"The time when the record was created. (Unix Timestamp)",
|
|
},
|
|
{
|
|
fieldName: "updated_at",
|
|
dataType: "INTEGER",
|
|
fieldDescription:
|
|
"The time when the record was updated. (Unix Timestamp)",
|
|
},
|
|
];
|