silosdk 0.0.0 → 0.0.1

package/dist/schema/index.mjs

@@ -0,0 +1,265 @@
+import { name } from "../package.mjs";
+
+//#region src/schema/index.ts
+function issue(message) {
+	return { message };
+}
+function validateString(input, options) {
+	const issues = [];
+	if (typeof input !== "string") {
+		issues.push({ message: "Expected string" });
+		return issues;
+	}
+	if (!options) return issues;
+	const { minLength, maxLength } = options;
+	if (typeof minLength === "number" && input.length < minLength) issues.push(issue(`Must be at least ${minLength} characters`));
+	if (typeof maxLength === "number" && input.length > maxLength) issues.push(issue(`Must be at most ${maxLength} characters`));
+	return issues;
+}
+function validateNumber(input, options) {
+	const issues = [];
+	if (typeof input !== "number") {
+		issues.push({ message: "Expected number" });
+		return issues;
+	}
+	if (!options) return issues;
+	const { min, max, integer } = options;
+	if (typeof min === "number" && input < min) issues.push(issue(`Must be at least ${min}`));
+	if (typeof max === "number" && input > max) issues.push(issue(`Must be at most ${max}`));
+	if (integer && !Number.isInteger(input)) issues.push(issue("Must be an integer"));
+	return issues;
+}
+function validateAsset(input) {
+	const issues = [];
+	if (typeof input !== "object" || input === null) {
+		issues.push({ message: "Expected asset object" });
+		return issues;
+	}
+	const hasKey = typeof input.key === "string" && input.key.length > 0;
+	const hasUri = typeof input.uri === "string" && input.uri.length > 0;
+	if (!hasKey && !hasUri) issues.push({ message: "Expected either non-empty key or uri" });
+	if (input.name !== void 0 && typeof input.name !== "string") issues.push({ message: "name must be a string" });
+	if (input.contentType !== void 0 && typeof input.contentType !== "string") issues.push({ message: "contentType must be a string" });
+	if (input.size !== void 0 && typeof input.size !== "number") issues.push({ message: "size must be a number" });
+	return issues;
+}
+function fieldSchema(type, options) {
+	function parse(value) {
+		return value;
+	}
+	function validate(input) {
+		const issues = [];
+		if (Array.isArray(type)) {
+			if (!type.includes(input)) {
+				issues.push({ message: `Expected one of: ${type.join(", ")}` });
+				return { issues };
+			}
+			return { value: parse(input) };
+		}
+		const def = options?.default;
+		if ((input === void 0 || input === null) && def !== void 0) input = typeof def === "function" ? def() : def;
+		switch (type) {
+			case "string":
+				issues.push(...validateString(input, options));
+				break;
+			case "number":
+				issues.push(...validateNumber(input, options));
+				break;
+			case "boolean":
+				if (typeof input !== "boolean") issues.push({ message: "Expected boolean" });
+				break;
+			case "asset":
+				issues.push(...validateAsset(input));
+				break;
+		}
+		if (issues.length > 0) return { issues };
+		else return { value: parse(input) };
+	}
+	return {
+		type,
+		options,
+		hasDefault: Boolean(options && options.default !== void 0),
+		validate,
+		"~standard": {
+			version: 1,
+			vendor: name,
+			validate
+		}
+	};
+}
+function string(options) {
+	return fieldSchema("string", options);
+}
+function number(options) {
+	return fieldSchema("number", options);
+}
+function boolean(options) {
+	return fieldSchema("boolean", options);
+}
+function asset(options) {
+	return fieldSchema("asset", options);
+}
+function literal(values, options) {
+	return fieldSchema(values, options);
+}
+function viewSchema(type) {
+	function parse(value) {
+		return value;
+	}
+	function validate(input) {
+		const issues = [];
+		if (typeof input !== "object" || input === null) {
+			issues.push({ message: "Expected object" });
+			return { issues };
+		}
+		const output = {};
+		Object.entries(type).forEach(([key, value]) => {
+			if (key in input) {
+				const res = value.validate(input[key]);
+				if ("issues" in res) res.issues?.forEach((issue$1) => {
+					issues.push({ message: `${key}: ${issue$1.message}` });
+				});
+				else output[key] = res.value;
+				return;
+			}
+			if (value.hasDefault) {
+				const res = value.validate(void 0);
+				if ("issues" in res) res.issues?.forEach((issue$1) => {
+					issues.push({ message: `${key}: ${issue$1.message}` });
+				});
+				else output[key] = res.value;
+			}
+		});
+		return issues.length > 0 ? { issues } : { value: parse(output) };
+	}
+	return {
+		type,
+		validate,
+		"~standard": {
+			version: 1,
+			vendor: name,
+			validate
+		}
+	};
+}
+function view(name$1, type) {
+	const schema = viewSchema(type);
+	const init = () => {
+		const value = {};
+		Object.keys(schema.type).forEach((key) => {
+			const field = schema.type[key];
+			if (field.options?.default !== void 0) {
+				const def = field.options.default;
+				value[key] = typeof def === "function" ? def() : def;
+			}
+		});
+		return value;
+	};
+	return {
+		name: name$1,
+		schema,
+		validate: schema["~standard"].validate,
+		init
+	};
+}
+function jex(field) {
+	return `json_extract(data, '$.${field}')`;
+}
+function stableStringify(obj) {
+	if (obj === null || obj === void 0) return "";
+	if (typeof obj !== "object") return String(obj);
+	if (Array.isArray(obj)) return obj.map(stableStringify).join(",");
+	return Object.keys(obj).sort().map((k) => `${k}:${stableStringify(obj[k])}`).join("|");
+}
+function compileWhere(where) {
+	const params = [];
+	const compileObject = (obj) => {
+		const parts = [];
+		for (const field of Object.keys(obj)) {
+			const value = obj[field];
+			if (value && Array.isArray(value)) {
+				const placeholders = value.map(() => "?").join(", ");
+				parts.push(`${jex(field)} IN (${placeholders})`);
+				params.push(...value);
+			} else if (value && typeof value === "object" && !Array.isArray(value)) for (const op of Object.keys(value)) {
+				parts.push(`${jex(field)} ${op} ?`);
+				params.push(value[op]);
+			}
+			else {
+				parts.push(`${jex(field)} = ?`);
+				params.push(value);
+			}
+		}
+		return parts.join(" AND ");
+	};
+	if (Array.isArray(where)) return {
+		clause: where.map((option) => `(${compileObject(option)})`).join(" OR "),
+		params
+	};
+	else return {
+		clause: compileObject(where),
+		params
+	};
+}
+async function getRows(args) {
+	const { name: name$1, options, db } = args;
+	let statement = `SELECT * FROM views WHERE view = ?`;
+	const params = [name$1];
+	const ids = [];
+	if (options && "parent" in options && options.parent) (await db.getAllAsync("SELECT * FROM relations WHERE parent = ? AND pid = ? AND child = ?", [
+		options?.parent?.[0]?.name,
+		options.parent[1],
+		name$1
+	])).forEach((relation) => {
+		ids.push(relation.cid);
+	});
+	if (options && "child" in options && options.child) (await db.getAllAsync("SELECT * FROM relations WHERE child = ? AND cid = ? AND parent = ?", [
+		options.child[0].name,
+		options.child[1],
+		name$1
+	])).forEach((relation) => {
+		ids.push(relation.pid);
+	});
+	if (ids.length > 0) {
+		statement += ` AND id IN (${ids.map(() => "?").join(",")})`;
+		params.push(...ids);
+	}
+	if (options.where) {
+		const { clause, params: whereParams } = compileWhere(options.where);
+		statement += ` AND (${clause})`;
+		params.push(...whereParams);
+	}
+	if (options.order) {
+		const orderClauses = [];
+		for (const [field, direction] of Object.entries(options.order)) orderClauses.push(`${jex(field)} ${direction?.toUpperCase() ?? "ASC"}`);
+		if (orderClauses.length > 0) statement += ` ORDER BY ${orderClauses.join(", ")}`;
+	}
+	if (options.take) {
+		statement += ` LIMIT ?`;
+		params.push(options.take);
+		if (args.offset) {
+			statement += ` OFFSET ?`;
+			params.push(args.offset);
+		}
+	}
+	return await db.getAllAsync(statement, params).then((rows) => rows.map((row) => ({
+		...row,
+		data: JSON.parse(row.data)
+	}))).catch((err) => {
+		console.error("DB Query Error:", err);
+	}) || [];
+}
+async function getRow(args) {
+	const { name: name$1, options, db } = args;
+	const statement = `SELECT * FROM views WHERE view = ? AND id = ?`;
+	const params = [name$1, options.id];
+	return await db.getFirstAsync(statement, params).then((row) => row ? {
+		...row,
+		data: JSON.parse(row.data)
+	} : null).catch((err) => {
+		console.error("DB Query Error:", err);
+	}) ?? null;
+}
+
+//#endregion
+export { asset, boolean, fieldSchema, getRow, getRows, jex, literal, number, stableStringify, string, view, viewSchema };

package/dist/server/auth.cjs

@@ -0,0 +1,132 @@
+
+//#region src/server/auth.ts
+const DEFAULT_SESSION_DURATION = 3600 * 24 * 30;
+function otpProvider(config) {
+	return {
+		_type: "otp",
+		config
+	};
+}
+function customProvider(fn) {
+	return {
+		_type: "custom",
+		resolve: fn
+	};
+}
+function createAuth(config) {
+	return {
+		_providers: config.providers,
+		_roles: config.roles,
+		_defaultRole: config.defaultRole ?? "user",
+		_sessionDuration: config.sessionDuration ?? DEFAULT_SESSION_DURATION
+	};
+}
+function randomDigits(n) {
+	const bytes = new Uint8Array(Math.ceil(n * 1.5));
+	crypto.getRandomValues(bytes);
+	return Array.from(bytes).map((b) => b % 10).join("").slice(0, n);
+}
+async function randomToken() {
+	const bytes = new Uint8Array(32);
+	crypto.getRandomValues(bytes);
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function findOrCreateUser(db, email, opts) {
+	const existing = await db.prepare(`SELECT id, email, role, createdAt FROM silo_users WHERE email = ?`).bind(email).first();
+	if (existing) return existing;
+	const id = await randomToken();
+	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+	const role = opts?.role ?? "user";
+	await db.prepare(`INSERT INTO silo_users (id, email, role, createdAt) VALUES (?, ?, ?, ?)`).bind(id, email, role, createdAt).run();
+	return {
+		id,
+		email,
+		role,
+		createdAt
+	};
+}
+async function createAnonymousUser(db, kv, durationSeconds = DEFAULT_SESSION_DURATION, defaultRole = "user") {
+	const id = await randomToken();
+	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+	const role = defaultRole;
+	await db.prepare(`INSERT INTO silo_users (id, email, role, createdAt) VALUES (?, NULL, ?, ?)`).bind(id, role, createdAt).run();
+	const token = await randomToken();
+	const payload = {
+		userId: id,
+		email: null,
+		role,
+		isAnonymous: true,
+		expiresAt: new Date(Date.now() + durationSeconds * 1e3).toISOString()
+	};
+	await kv.put(`session:${token}`, JSON.stringify(payload), { expirationTtl: durationSeconds });
+	return {
+		token,
+		userId: id
+	};
+}
+const OTP_TTL_SECONDS = 600;
+async function createOtp(db, email) {
+	const code = randomDigits(6);
+	const expiresAt = new Date(Date.now() + OTP_TTL_SECONDS * 1e3).toISOString();
+	await db.prepare(`INSERT INTO silo_otps (email, code, expiresAt)
+       VALUES (?, ?, ?)
+       ON CONFLICT(email) DO UPDATE SET
+         code = excluded.code,
+         expiresAt = excluded.expiresAt`).bind(email, code, expiresAt).run();
+	return code;
+}
+async function verifyOtp(db, email, code) {
+	const row = await db.prepare(`SELECT code, expiresAt FROM silo_otps WHERE email = ?`).bind(email).first();
+	if (!row) return { valid: false };
+	if (row.code !== code) return { valid: false };
+	if (new Date(row.expiresAt) < /* @__PURE__ */ new Date()) return { valid: false };
+	await db.prepare(`DELETE FROM silo_otps WHERE email = ?`).bind(email).run();
+	return { valid: true };
+}
+async function createSession(kv, userId, email, role, durationSeconds = DEFAULT_SESSION_DURATION) {
+	const token = await randomToken();
+	const payload = {
+		userId,
+		email,
+		role,
+		isAnonymous: false,
+		expiresAt: new Date(Date.now() + durationSeconds * 1e3).toISOString()
+	};
+	await kv.put(`session:${token}`, JSON.stringify(payload), { expirationTtl: durationSeconds });
+	return token;
+}
+async function resolveSession(kv, token) {
+	const raw = await kv.get(`session:${token}`);
+	if (!raw) return null;
+	let payload;
+	try {
+		payload = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (new Date(payload.expiresAt) < /* @__PURE__ */ new Date()) {
+		await kv.delete(`session:${token}`);
+		return null;
+	}
+	return {
+		id: payload.userId,
+		email: payload.email,
+		role: payload.role,
+		isAnonymous: payload.isAnonymous
+	};
+}
+async function deleteSession(kv, token) {
+	await kv.delete(`session:${token}`);
+}
+
+//#endregion
+exports.createAnonymousUser = createAnonymousUser;
+exports.createAuth = createAuth;
+exports.createOtp = createOtp;
+exports.createSession = createSession;
+exports.customProvider = customProvider;
+exports.deleteSession = deleteSession;
+exports.findOrCreateUser = findOrCreateUser;
+exports.otpProvider = otpProvider;
+exports.resolveSession = resolveSession;
+exports.verifyOtp = verifyOtp;

package/dist/server/auth.d.cts

@@ -0,0 +1,49 @@
+//#region src/server/auth.d.ts
+type OtpProviderConfig = {
+  sendOTP: (to: string, code: string, env: unknown) => Promise<void>;
+};
+type OtpProvider = {
+  _type: 'otp';
+  config: OtpProviderConfig;
+};
+type CustomProvider = {
+  _type: 'custom';
+  resolve: (token: string) => Promise<{
+    id: string;
+    role?: string;
+  } | null>;
+};
+type ViewPermissions = {
+  read: boolean;
+  write: boolean;
+};
+type RoleDefinition = {
+  default: ViewPermissions;
+  [viewName: string]: ViewPermissions;
+};
+type RolesConfig = Record<string, RoleDefinition>;
+type CreateAuthConfig = {
+  providers: OtpProvider[] | CustomProvider;
+  roles?: RolesConfig;
+  defaultRole?: string;
+  sessionDuration?: number;
+};
+type AuthInstance = {
+  _providers: OtpProvider[] | CustomProvider;
+  _roles: RolesConfig | undefined;
+  _defaultRole: string;
+  _sessionDuration: number;
+};
+declare function otpProvider(config: OtpProviderConfig): OtpProvider;
+declare function customProvider(fn: (token: string) => Promise<{
+  id: string;
+} | null>): CustomProvider;
+declare function createAuth(config: CreateAuthConfig): AuthInstance;
+declare function resolveSession(kv: KVNamespace, token: string): Promise<{
+  id: string;
+  email: string | null;
+  role: string;
+  isAnonymous: boolean;
+} | null>;
+//#endregion
+export { AuthInstance, RoleDefinition, RolesConfig, ViewPermissions, createAuth, customProvider, otpProvider, resolveSession };

package/dist/server/auth.d.mts

@@ -0,0 +1,49 @@
+//#region src/server/auth.d.ts
+type OtpProviderConfig = {
+  sendOTP: (to: string, code: string, env: unknown) => Promise<void>;
+};
+type OtpProvider = {
+  _type: 'otp';
+  config: OtpProviderConfig;
+};
+type CustomProvider = {
+  _type: 'custom';
+  resolve: (token: string) => Promise<{
+    id: string;
+    role?: string;
+  } | null>;
+};
+type ViewPermissions = {
+  read: boolean;
+  write: boolean;
+};
+type RoleDefinition = {
+  default: ViewPermissions;
+  [viewName: string]: ViewPermissions;
+};
+type RolesConfig = Record<string, RoleDefinition>;
+type CreateAuthConfig = {
+  providers: OtpProvider[] | CustomProvider;
+  roles?: RolesConfig;
+  defaultRole?: string;
+  sessionDuration?: number;
+};
+type AuthInstance = {
+  _providers: OtpProvider[] | CustomProvider;
+  _roles: RolesConfig | undefined;
+  _defaultRole: string;
+  _sessionDuration: number;
+};
+declare function otpProvider(config: OtpProviderConfig): OtpProvider;
+declare function customProvider(fn: (token: string) => Promise<{
+  id: string;
+} | null>): CustomProvider;
+declare function createAuth(config: CreateAuthConfig): AuthInstance;
+declare function resolveSession(kv: KVNamespace, token: string): Promise<{
+  id: string;
+  email: string | null;
+  role: string;
+  isAnonymous: boolean;
+} | null>;
+//#endregion
+export { AuthInstance, RoleDefinition, RolesConfig, ViewPermissions, createAuth, customProvider, otpProvider, resolveSession };

package/dist/server/auth.mjs

@@ -0,0 +1,122 @@
+//#region src/server/auth.ts
+const DEFAULT_SESSION_DURATION = 3600 * 24 * 30;
+function otpProvider(config) {
+	return {
+		_type: "otp",
+		config
+	};
+}
+function customProvider(fn) {
+	return {
+		_type: "custom",
+		resolve: fn
+	};
+}
+function createAuth(config) {
+	return {
+		_providers: config.providers,
+		_roles: config.roles,
+		_defaultRole: config.defaultRole ?? "user",
+		_sessionDuration: config.sessionDuration ?? DEFAULT_SESSION_DURATION
+	};
+}
+function randomDigits(n) {
+	const bytes = new Uint8Array(Math.ceil(n * 1.5));
+	crypto.getRandomValues(bytes);
+	return Array.from(bytes).map((b) => b % 10).join("").slice(0, n);
+}
+async function randomToken() {
+	const bytes = new Uint8Array(32);
+	crypto.getRandomValues(bytes);
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function findOrCreateUser(db, email, opts) {
+	const existing = await db.prepare(`SELECT id, email, role, createdAt FROM silo_users WHERE email = ?`).bind(email).first();
+	if (existing) return existing;
+	const id = await randomToken();
+	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+	const role = opts?.role ?? "user";
+	await db.prepare(`INSERT INTO silo_users (id, email, role, createdAt) VALUES (?, ?, ?, ?)`).bind(id, email, role, createdAt).run();
+	return {
+		id,
+		email,
+		role,
+		createdAt
+	};
+}
+async function createAnonymousUser(db, kv, durationSeconds = DEFAULT_SESSION_DURATION, defaultRole = "user") {
+	const id = await randomToken();
+	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+	const role = defaultRole;
+	await db.prepare(`INSERT INTO silo_users (id, email, role, createdAt) VALUES (?, NULL, ?, ?)`).bind(id, role, createdAt).run();
+	const token = await randomToken();
+	const payload = {
+		userId: id,
+		email: null,
+		role,
+		isAnonymous: true,
+		expiresAt: new Date(Date.now() + durationSeconds * 1e3).toISOString()
+	};
+	await kv.put(`session:${token}`, JSON.stringify(payload), { expirationTtl: durationSeconds });
+	return {
+		token,
+		userId: id
+	};
+}
+const OTP_TTL_SECONDS = 600;
+async function createOtp(db, email) {
+	const code = randomDigits(6);
+	const expiresAt = new Date(Date.now() + OTP_TTL_SECONDS * 1e3).toISOString();
+	await db.prepare(`INSERT INTO silo_otps (email, code, expiresAt)
+       VALUES (?, ?, ?)
+       ON CONFLICT(email) DO UPDATE SET
+         code = excluded.code,
+         expiresAt = excluded.expiresAt`).bind(email, code, expiresAt).run();
+	return code;
+}
+async function verifyOtp(db, email, code) {
+	const row = await db.prepare(`SELECT code, expiresAt FROM silo_otps WHERE email = ?`).bind(email).first();
+	if (!row) return { valid: false };
+	if (row.code !== code) return { valid: false };
+	if (new Date(row.expiresAt) < /* @__PURE__ */ new Date()) return { valid: false };
+	await db.prepare(`DELETE FROM silo_otps WHERE email = ?`).bind(email).run();
+	return { valid: true };
+}
+async function createSession(kv, userId, email, role, durationSeconds = DEFAULT_SESSION_DURATION) {
+	const token = await randomToken();
+	const payload = {
+		userId,
+		email,
+		role,
+		isAnonymous: false,
+		expiresAt: new Date(Date.now() + durationSeconds * 1e3).toISOString()
+	};
+	await kv.put(`session:${token}`, JSON.stringify(payload), { expirationTtl: durationSeconds });
+	return token;
+}
+async function resolveSession(kv, token) {
+	const raw = await kv.get(`session:${token}`);
+	if (!raw) return null;
+	let payload;
+	try {
+		payload = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (new Date(payload.expiresAt) < /* @__PURE__ */ new Date()) {
+		await kv.delete(`session:${token}`);
+		return null;
+	}
+	return {
+		id: payload.userId,
+		email: payload.email,
+		role: payload.role,
+		isAnonymous: payload.isAnonymous
+	};
+}
+async function deleteSession(kv, token) {
+	await kv.delete(`session:${token}`);
+}
+
+//#endregion
+export { createAnonymousUser, createAuth, createOtp, createSession, customProvider, deleteSession, findOrCreateUser, otpProvider, resolveSession, verifyOtp };