@ragestudio/scylla-odm 0.1.0 → 0.2.0

package/src/result/index.ts

@@ -1,90 +0,0 @@
-import type { Model } from "../model"
-import typeChecker from "../utils/typeChecker"
-
-export class Result<TDoc = any> {
-	constructor(data: TDoc, model: Model<TDoc>) {
-		if (data == null) {
-			throw new Error("Cannot create Result with null or undefined data")
-		}
-
-		if (typeof data !== "object" || Array.isArray(data)) {
-			throw new Error("Result data must be an object")
-		}
-
-		Object.assign(this, data)
-
-		Object.defineProperty(this, "_model", {
-			value: model,
-			enumerable: false,
-			writable: false,
-			configurable: false,
-		})
-	}
-
-	_model: Model<TDoc>
-
-	async save() {
-		try {
-			const data = this.toRaw()
-
-			typeChecker(this._model, data)
-
-			return await this._model.update(data as any)
-		} catch (error: any) {
-			throw new Error(`Failed to save result: ${error.message}`)
-		}
-	}
-
-	async delete() {
-		try {
-			return await this._model.delete(this.toRaw() as any)
-		} catch (error: any) {
-			throw new Error(`Failed to delete result: ${error.message}`)
-		}
-	}
-
-	toRaw(): TDoc {
-		const raw: any = {}
-
-		for (const key in this) {
-			if (key === "_model") continue
-
-			if (this.propertyIsEnumerable(key)) {
-				const value = (this as any)[key]
-
-				try {
-					JSON.stringify(value)
-					raw[key] = value
-				} catch (error) {
-					raw[key] = String(value)
-				}
-			}
-		}
-
-		return raw as TDoc
-	}
-
-	isValid(): boolean {
-		try {
-			typeChecker(this._model, this.toRaw())
-			return true
-		} catch {
-			return false
-		}
-	}
-
-	getChangedFields(original: Partial<TDoc>): (keyof TDoc)[] {
-		const current = this.toRaw() as Record<string, any>
-		const changed: (keyof TDoc)[] = []
-
-		for (const key in current) {
-			if (!(key in original) || current[key] !== (original as any)[key]) {
-				changed.push(key as keyof TDoc)
-			}
-		}
-
-		return changed
-	}
-}
-
-export default Result

package/src/schema/index.ts

@@ -1,16 +0,0 @@
-import { TableKeys } from "../types"
-
-export class Schema<T> {
-	public readonly table_name: string
-	public readonly clustering_order: any
-	public readonly keys: TableKeys
-	public readonly fields: T
-
-	constructor(params: any, fields: T) {
-		this.table_name = params.table_name
-		this.keys = params.keys
-		this.fields = fields
-	}
-}
-
-export default Schema

package/src/types.ts

@@ -1,89 +0,0 @@
-import Result from "./result"
-import { Schema } from "./schema"
-
-export type ClientConfig = {
-	modelsPath?: string
-	contactPoints?: string[]
-	localDataCenter?: string
-	keyspace?: string
-	port?: number
-	maxRetries?: number
-	retryDelay?: number
-	pooling?: {
-		coreConnectionsPerHost?: Record<string, number>
-		maxRequestsPerConnection?: number
-	}
-}
-
-export enum ColumnTypes {
-	Ascii = "ascii",
-	Bigint = "bigint",
-	Blob = "blob",
-	Boolean = "boolean",
-	Counter = "counter",
-	Date = "date",
-	Decimal = "decimal",
-	Double = "double",
-	Duration = "duration",
-	Float = "float",
-	Frozen = "frozen",
-	Inet = "inet",
-	Int = "int",
-	List = "list",
-	Map = "map",
-	Set = "set",
-	Smallint = "smallint",
-	Text = "text",
-	Time = "time",
-	Timestamp = "timestamp",
-	Timeuuid = "timeuuid",
-	Tinyint = "tinyint",
-	Tuple = "tuple",
-	Uuid = "uuid",
-	Varchar = "varchar",
-	Varint = "varint",
-}
-
-export type QueryOperators<TValue> = {
-	$eq?: TValue
-	$ne?: TValue
-	$in?: TValue[]
-	$gt?: TValue
-	$gte?: TValue
-	$lt?: TValue
-	$lte?: TValue
-}
-
-export type TableKeys = (string | TableKeys)[]
-
-export interface Column<T> {
-	type?: ColumnTypes | string
-	required?: boolean
-}
-
-export type InferRawData<T> = {
-	[K in keyof T as K extends `$${string}` ? never : K]: T[K] extends Column<
-		infer U
-	>
-		? U
-		: T[K]
-}
-
-export type InferDocument<S> =
-	S extends Schema<infer T> ? InferRawData<T> : never
-
-export type DocumentResult<TDoc> = Result<TDoc> & TDoc
-
-export type QueryOptions = {
-	raw?: boolean
-}
-
-export type OrderBy<TDoc> = { [K in keyof TDoc]?: "asc" | "desc" }
-
-export type Query<TDoc> = {
-	[K in keyof TDoc]?: TDoc[K] | QueryOperators<TDoc[K]>
-} & {
-	$and?: Query<TDoc>[]
-	$limit?: number
-	$orderby?: OrderBy<TDoc>
-}

package/src/utils/buildMapper.js

@@ -1,10 +0,0 @@
-export default (map) => {
-	return map.reduce((obj, { name, schema }) => {
-		return {
-			...obj,
-			[name]: {
-				tables: [schema.table_name],
-			},
-		}
-	}, {})
-}

package/src/utils/fillDefaults.ts

@@ -1,30 +0,0 @@
-export default function fillDefaults(schema: any, data: any) {
-	const defaults = schema.options?.defaults
-
-	if (!defaults || Object.keys(defaults).length === 0) {
-		return data
-	}
-
-	let needsDefaults = false
-
-	for (const key in defaults) {
-		if (data[key] == null) {
-			needsDefaults = true
-			break
-		}
-	}
-
-	if (!needsDefaults) {
-		return data
-	}
-
-	const result = Object.assign({}, data)
-
-	for (const key in defaults) {
-		if (result[key] == null) {
-			result[key] = defaults[key]
-		}
-	}
-
-	return result
-}

package/src/utils/loadSchemas.ts

@@ -1,39 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-export default async (fromPath: string): Promise<any[]> => {
-	if (typeof fromPath !== "string") {
-		return []
-	}
-
-	if (!fs.existsSync(fromPath)) {
-		console.warn(
-			`Cannot load models from [${fromPath}] case this path does not exist`,
-		)
-		return []
-	}
-
-	let schemas = []
-
-	let files = await fs.promises.readdir(fromPath)
-
-	files = files.filter((file) => file.endsWith(".js") || file.endsWith(".ts"))
-
-	for await (const file of files) {
-		const name = file.replace(".js", "")
-		const file_path = path.join(fromPath, file)
-
-		try {
-			let mod = await import(file_path)
-
-			mod = mod.default
-
-			schemas.push(mod)
-		} catch (error) {
-			console.error(`Failed to load schema [${name}]:`, error)
-			continue
-		}
-	}
-
-	return schemas
-}

package/src/utils/queryParser.ts

@@ -1,192 +0,0 @@
-import type { Model } from "../model"
-
-// @ts-ignore
-import cassandra from "cassandra-driver"
-const { q } = cassandra.mapping
-
-const MAX_QUERY_DEPTH = 3
-const MAX_IN_ELEMENTS = 1000
-
-const VALID_OPERATORS = new Set([
-	"$eq",
-	"$ne",
-	"$gt",
-	"$gte",
-	"$lt",
-	"$lte",
-	"$in",
-])
-
-function requireNotNull(value: any, operator: string): void {
-	if (value === null || value === undefined) {
-		throw new Error(
-			`${operator} operator cannot compare with null or undefined`,
-		)
-	}
-}
-
-function buildOperator(operator: string, opValue: any): any {
-	if (!VALID_OPERATORS.has(operator)) {
-		throw new Error(`Invalid operator: ${operator}`)
-	}
-
-	switch (operator) {
-		case "$eq":
-			return opValue
-
-		case "$ne":
-			requireNotNull(opValue, "$ne")
-			return q.notEq(opValue)
-
-		case "$in":
-			if (!Array.isArray(opValue)) {
-				throw new Error("$in operator requires an array")
-			}
-			if (opValue.length > MAX_IN_ELEMENTS) {
-				throw new Error(
-					`$in operator exceeds maximum of ${MAX_IN_ELEMENTS} elements`,
-				)
-			}
-			for (let i = 0; i < opValue.length; i++) {
-				if (opValue[i] === null || opValue[i] === undefined) {
-					throw new Error(
-						`$in array element at index ${i} cannot be null or undefined`,
-					)
-				}
-			}
-			return q.in_(opValue)
-
-		case "$gt":
-			requireNotNull(opValue, "$gt")
-			return q.gt(opValue)
-
-		case "$gte":
-			requireNotNull(opValue, "$gte")
-			return q.gte(opValue)
-
-		case "$lt":
-			requireNotNull(opValue, "$lt")
-			return q.lt(opValue)
-
-		case "$lte":
-			requireNotNull(opValue, "$lte")
-			return q.lte(opValue)
-	}
-}
-
-export default function queryParser(
-	model: Model<any>,
-	query: any,
-	depth: number = 0,
-) {
-	if (depth > MAX_QUERY_DEPTH) {
-		throw new Error(`Query depth exceeds maximum of ${MAX_QUERY_DEPTH}`)
-	}
-
-	if (!query || typeof query !== "object") {
-		return query
-	}
-
-	const parsedQuery: Record<string, any> = {}
-	const fields = model.schema.fields
-
-	for (const field of Object.keys(query)) {
-		const value = query[field]
-
-		if (field === "$and") {
-			handleAnd(model, value, parsedQuery, depth)
-			continue
-		}
-
-		if (field === "$or") {
-			throw new Error(
-				"ScyllaDB does not support OR queries across different columns. Use $in for a single column.",
-			)
-		}
-
-		if (!isValidFieldName(fields, field)) {
-			throw new Error(
-				`Invalid field name: [${field}] or it does not exist in schema`,
-			)
-		}
-
-		parsedQuery[field] = parseField(value)
-	}
-
-	return parsedQuery
-}
-
-function handleAnd(
-	model: Model<any>,
-	conditions: any,
-	parsedQuery: Record<string, any>,
-	depth: number,
-) {
-	if (!Array.isArray(conditions)) {
-		throw new Error("$and operator requires an array")
-	}
-	if (conditions.length > 10) {
-		throw new Error("$and operator exceeds maximum of 10 conditions")
-	}
-
-	for (let i = 0; i < conditions.length; i++) {
-		const condition = conditions[i]
-		if (!condition || typeof condition !== "object") {
-			throw new Error(`$and condition at index ${i} must be an object`)
-		}
-
-		const parsed = queryParser(model, condition, depth + 1)
-		for (const key of Object.keys(parsed)) {
-			if (key in parsedQuery) {
-				throw new Error(
-					`$and conflict: field "${key}" appears in multiple conditions`,
-				)
-			}
-		}
-		Object.assign(parsedQuery, parsed)
-	}
-}
-
-function parseField(value: any): any {
-	if (
-		value === null ||
-		typeof value !== "object" ||
-		Array.isArray(value) ||
-		value instanceof Date
-	) {
-		if (Array.isArray(value)) {
-			throw new Error(
-				"Array values require explicit operator (e.g., $in)",
-			)
-		}
-		return value
-	}
-
-	const operators = Object.keys(value)
-	const compiledOps = operators.map((op) => buildOperator(op, value[op]))
-
-	return compiledOps.length === 1
-		? compiledOps[0]
-		: (q.and as any)(...compiledOps)
-}
-
-export function isValidFieldName(
-	fields: Record<string, any>,
-	fieldName: string,
-): boolean {
-	const invalidPatterns = [
-		/^[0-9]/,
-		/[^a-zA-Z0-9_]/,
-		/^(select|insert|update|delete|drop|create|alter|truncate)$/i,
-	]
-
-	for (const pattern of invalidPatterns) {
-		if (pattern.test(fieldName)) return false
-	}
-
-	return fieldName in fields
-}
-
-export function isValidOperator(operator: string): boolean {
-	return VALID_OPERATORS.has(operator)
-}

package/src/utils/typeChecker.ts

@@ -1,100 +0,0 @@
-// @ts-ignore
-import cassandra from "cassandra-driver"
-const { types } = cassandra
-import type { Model } from "../model"
-import { isValidFieldName } from "./queryParser"
-
-const stringTypes = new Set(["ascii", "text", "varchar", "inet"])
-const intTypes = new Set(["int", "smallint", "tinyint"])
-const floatTypes = new Set(["double", "float"])
-const longTypes = new Set(["bigint", "counter"])
-
-function isValidValue(value: any, expectedType: string): boolean {
-	if (value === null || value === undefined) return true
-
-	if (stringTypes.has(expectedType)) return typeof value === "string"
-	if (intTypes.has(expectedType)) return Number.isInteger(value)
-	if (floatTypes.has(expectedType)) return typeof value === "number"
-	if (longTypes.has(expectedType)) {
-		return (
-			typeof value === "bigint" ||
-			typeof value === "number" ||
-			value instanceof types.Long
-		)
-	}
-
-	switch (expectedType) {
-		case "boolean":
-			return typeof value === "boolean"
-		case "decimal":
-			return (
-				typeof value === "number" ||
-				typeof value === "string" ||
-				value instanceof types.BigDecimal
-			)
-		case "varint":
-			return (
-				typeof value === "bigint" ||
-				typeof value === "number" ||
-				value instanceof types.Integer
-			)
-		case "timestamp":
-			return (
-				value instanceof Date ||
-				typeof value === "number" ||
-				typeof value === "string"
-			)
-		case "date":
-			return typeof value === "string" || value instanceof types.LocalDate
-		case "time":
-			return typeof value === "string" || value instanceof types.LocalTime
-		case "uuid":
-			return typeof value === "string" || value instanceof types.Uuid
-		case "timeuuid":
-			return typeof value === "string" || value instanceof types.TimeUuid
-		case "blob":
-			return Buffer.isBuffer(value) || value instanceof Uint8Array
-	}
-
-	if (expectedType.startsWith("list<") || expectedType.startsWith("set<")) {
-		return Array.isArray(value) || value instanceof Set
-	}
-	if (expectedType.startsWith("map<")) {
-		return (
-			typeof value === "object" && !Array.isArray(value) && value !== null
-		)
-	}
-
-	return false
-}
-
-export default function typeChecker(model: Model<any>, data: any): boolean {
-	if (!data || typeof data !== "object" || Array.isArray(data)) {
-		throw new TypeError(
-			`[${model.name}] Validation error: Data payload must be an object`,
-		)
-	}
-
-	const fields = model.schema.fields
-
-	for (const [key, value] of Object.entries(data)) {
-		if (!isValidFieldName(fields, key)) {
-			throw new Error(
-				`[${model.name}] Validation error: Field '${key}' does not exist in schema`,
-			)
-		}
-
-		const fieldConfig = fields[key]
-		const expectedType = (fieldConfig.type || "text").toLowerCase()
-
-		if (!isValidValue(value, expectedType)) {
-			const receivedType = Array.isArray(value) ? "array" : typeof value
-			throw new TypeError(
-				`[${model.name}] Validation error: Invalid type for field '${key}'. ` +
-					`Expected[${expectedType}], but received [${receivedType}]`,
-			)
-		}
-	}
-
-	return true
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "$schema": "http://json.schemastore.org/tsconfig",
-  "compilerOptions": {
-    "allowSyntheticDefaultImports": true,
-    "target": "ES2023",
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "declaration": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "strict": false,
-    "noImplicitAny": false,
-    "skipLibCheck": true,
-    "preserveConstEnums": true,
-    "sourceMap": true,
-    "baseUrl": ".",
-  },
-  "include": ["**/*.ts"],
-}