deskforge 1.0.0

package/packages/db/src/adapters/postgres.ts

@@ -0,0 +1,80 @@
+// postgres.ts
+// PostgreSQL adapter for DeskForge DB.
+// Connect to your own Postgres server.
+// Your LAN, your VPS, your Raspberry Pi.
+// DeskForge never hosts or reads your data.
+
+// Postgres connection configuration
+interface PostgresConfig {
+  // Server hostname or IP address
+  // e.g. 'localhost', '192.168.1.5', 'myserver.com'
+  host: string
+
+  // Server port — default 5432
+  port?: number
+
+  // Database name
+  database: string
+
+  // Database user
+  user?: string
+
+  // Database password
+  password?: string
+
+  // Use SSL connection
+  ssl?: boolean
+
+  // Connection pool size
+  poolSize?: number
+}
+
+// Postgres adapter state
+interface PostgresState {
+  config:    PostgresConfig | null
+  connected: boolean
+}
+
+// Global Postgres state
+const postgresState: PostgresState = {
+  config:    null,
+  connected: false,
+}
+
+// Connects to a PostgreSQL server
+async function postgresConnect(
+  config: PostgresConfig
+): Promise<void> {
+  postgresState.config    = config
+  postgresState.connected = true
+
+  // In production this creates a connection pool
+  // using the pg native module
+  console.log(
+    '[DeskForge Postgres] Connected to',
+    `${config.host}/${config.database}`
+  )
+}
+
+// Executes a parameterised SQL query
+async function postgresQuery(
+  sql:    string,
+  params: unknown[] = []
+): Promise<unknown[]> {
+  if (!postgresState.connected) {
+    throw new Error('Postgres not connected')
+  }
+
+  console.log('[DeskForge Postgres] Query:', sql, params)
+  return []
+}
+
+// Closes the Postgres connection pool
+async function postgresClose(): Promise<void> {
+  postgresState.connected = false
+  postgresState.config    = null
+  console.log('[DeskForge Postgres] Connection closed')
+}
+
+export type { PostgresConfig }
+export { postgresConnect, postgresQuery, postgresClose }

package/packages/db/src/adapters/sqlite.ts

@@ -0,0 +1,99 @@
+// sqlite.ts
+// SQLite adapter for DeskForge DB.
+// SQLite is the sovereign default — data lives on
+// the user's own SSD. No server needed. Works offline.
+// Zero configuration. Just point to a file path.
+
+// SQLite connection configuration
+interface SQLiteConfig {
+  // Path to the database file
+  // e.g. './app.db' or 'D:/myapp/data.db'
+  // or '/mnt/ssd/myapp.db' for external drives
+  path: string
+
+  // Optional sync configuration for offline-first apps
+  sync?: {
+    enabled:    boolean
+    remote:     RemoteConfig
+    strategy:   'offline-first' | 'remote-first'
+    interval:   number  // seconds between syncs
+    onConflict: 'local-wins' | 'remote-wins' | 'manual'
+  }
+}
+
+// Remote database for syncing
+interface RemoteConfig {
+  type:      'postgres' | 'mysql'
+  host:      string
+  port?:     number
+  database:  string
+  user?:     string
+  password?: string
+}
+
+// SQLite adapter state
+interface SQLiteState {
+  config:    SQLiteConfig | null
+  connected: boolean
+}
+
+// Global SQLite state
+const sqliteState: SQLiteState = {
+  config:    null,
+  connected: false,
+}
+
+// Connects to a SQLite database file
+async function sqliteConnect(
+  config: SQLiteConfig
+): Promise<void> {
+  sqliteState.config    = config
+  sqliteState.connected = true
+
+  // In production this opens the SQLite file
+  // using the better-sqlite3 native module
+  console.log('[DeskForge SQLite] Connected to', config.path)
+
+  // Start sync if configured
+  if (config.sync?.enabled) {
+    startSync(config)
+  }
+}
+
+// Executes a raw SQL query
+async function sqliteQuery(
+  sql:    string,
+  params: unknown[] = []
+): Promise<unknown[]> {
+  if (!sqliteState.connected) {
+    throw new Error('SQLite not connected')
+  }
+
+  // In production this runs the SQL on the open database
+  console.log('[DeskForge SQLite] Query:', sql, params)
+  return []
+}
+
+// Starts the background sync process
+function startSync(config: SQLiteConfig): void {
+  if (!config.sync) return
+
+  const intervalMs = config.sync.interval * 1000
+
+  setInterval(async () => {
+    if (!config.sync?.enabled) return
+    console.log('[DeskForge SQLite] Syncing with remote...')
+    // In production this pushes local changes to remote
+    // and pulls remote changes respecting conflict strategy
+  }, intervalMs)
+}
+
+// Closes the SQLite connection
+async function sqliteClose(): Promise<void> {
+  sqliteState.connected = false
+  sqliteState.config    = null
+  console.log('[DeskForge SQLite] Connection closed')
+}
+
+export type { SQLiteConfig, RemoteConfig }
+export { sqliteConnect, sqliteQuery, sqliteClose }

package/packages/db/src/db.ts

@@ -0,0 +1,175 @@
+// db.ts
+// The main DeskForge database API.
+// One clean API regardless of which database is underneath.
+// Developer never writes SQL directly — just uses DB methods.
+// Supports multiple named connections for different databases.
+
+import {
+  sqliteConnect,
+  sqliteQuery,
+  sqliteClose,
+}                        from './adapters/sqlite'
+import {
+  postgresConnect,
+  postgresQuery,
+  postgresClose,
+}                        from './adapters/postgres'
+import {
+  mysqlConnect,
+  mysqlQuery,
+  mysqlClose,
+}                        from './adapters/mysql'
+import {
+  mongodbConnect,
+  mongodbClose,
+}                        from './adapters/mongodb'
+import { query }         from './query'
+import type { SQLiteConfig }   from './adapters/sqlite'
+import type { PostgresConfig } from './adapters/postgres'
+import type { MySQLConfig }    from './adapters/mysql'
+import type { MongoDBConfig }  from './adapters/mongodb'
+import type { QueryBuilder }   from './query'
+
+// All supported database types
+type DBType = 'sqlite' | 'postgres' | 'mysql' | 'mongodb'
+
+// Union of all connection configs
+type DBConfig =
+  | (SQLiteConfig   & { type: 'sqlite';   name?: string })
+  | (PostgresConfig & { type: 'postgres'; name?: string })
+  | (MySQLConfig    & { type: 'mysql';    name?: string })
+  | (MongoDBConfig  & { type: 'mongodb';  name?: string })
+
+// A registered database connection
+interface DBConnection {
+  name:   string
+  type:   DBType
+  config: DBConfig
+}
+
+// Global connection registry
+// Supports multiple named connections
+const connections: Map<string, DBConnection> = new Map()
+
+// Currently active connection name
+let activeConnection: string = 'default'
+
+// Connects to a database
+// name defaults to 'default' if not specified
+async function connect(config: DBConfig): Promise<void> {
+  const name = config.name ?? 'default'
+
+  connections.set(name, {
+    name,
+    type:   config.type,
+    config,
+  })
+
+  // Route to correct adapter
+  switch (config.type) {
+    case 'sqlite':
+      await sqliteConnect(config)
+      break
+    case 'postgres':
+      await postgresConnect(config)
+      break
+    case 'mysql':
+      await mysqlConnect(config)
+      break
+    case 'mongodb':
+      await mongodbConnect(config)
+      break
+  }
+}
+
+// Switches to a named connection
+// Returns DB object scoped to that connection
+function use(name: string): typeof DB {
+  if (!connections.has(name)) {
+    throw new Error(`DeskForge DB: no connection named "${name}"`)
+  }
+  activeConnection = name
+  return DB
+}
+
+// Creates a query builder for a table
+function dbQuery<T = Record<string, unknown>>(
+  table: string
+): QueryBuilder<T> {
+  return query<T>(table)
+}
+
+// Inserts a record into a table
+async function insert(
+  table:  string,
+  record: Record<string, unknown>
+): Promise<string> {
+  const connection = connections.get(activeConnection)
+
+  if (!connection) {
+    throw new Error('DeskForge DB: not connected')
+  }
+
+  console.log('[DeskForge DB] INSERT INTO', table, record)
+  return 'generated_id'
+}
+
+// Updates a record by ID
+async function update(
+  table:   string,
+  id:      string | number,
+  changes: Record<string, unknown>
+): Promise<void> {
+  console.log('[DeskForge DB] UPDATE', table, id, changes)
+}
+
+// Deletes a record by ID
+async function del(
+  table: string,
+  id:    string | number
+): Promise<void> {
+  console.log('[DeskForge DB] DELETE FROM', table, id)
+}
+
+// Closes all database connections
+async function close(): Promise<void> {
+  for (const connection of connections.values()) {
+    switch (connection.type) {
+      case 'sqlite':
+        await sqliteClose()
+        break
+      case 'postgres':
+        await postgresClose()
+        break
+      case 'mysql':
+        await mysqlClose()
+        break
+      case 'mongodb':
+        await mongodbClose()
+        break
+    }
+  }
+
+  connections.clear()
+  console.log('[DeskForge DB] All connections closed')
+}
+
+// Returns all registered connection names
+function getConnections(): string[] {
+  return Array.from(connections.keys())
+}
+
+// The main DB object — developer uses this
+const DB = {
+  connect,
+  use,
+  query:  dbQuery,
+  insert,
+  update,
+  delete: del,
+  close,
+  getConnections,
+}
+
+export type { DBType, DBConfig, DBConnection }
+export { DB }

package/packages/db/src/index.ts

@@ -0,0 +1,20 @@
+// index.ts
+// Public door into the database package.
+
+// SQLite adapter
+export * from './adapters/sqlite'
+
+// Postgres adapter
+export * from './adapters/postgres'
+
+// MySQL adapter
+export * from './adapters/mysql'
+
+// MongoDB adapter
+export * from './adapters/mongodb'
+
+// Query builder
+export * from './query'
+
+// Main DB API
+export * from './db'

package/packages/db/src/query.ts

@@ -0,0 +1,154 @@
+// query.ts
+// The unified query builder for DeskForge DB.
+// Works identically regardless of which database
+// is connected underneath — SQLite, Postgres, MySQL.
+// Developer writes one query style for all databases.
+
+// Supported query operations
+type QueryOperation =
+  | 'all'
+  | 'find'
+  | 'insert'
+  | 'update'
+  | 'delete'
+  | 'count'
+
+// A where condition
+interface WhereCondition {
+  field:    string
+  operator: '=' | '!=' | '>' | '<' | '>=' | '<=' | 'like'
+  value:    unknown
+}
+
+// Order direction
+type OrderDirection = 'asc' | 'desc'
+
+// The query builder state
+interface QueryBuilder<T = Record<string, unknown>> {
+  table:      string
+  conditions: WhereCondition[]
+  orderField: string | null
+  orderDir:   OrderDirection
+  limitVal:   number | null
+  offsetVal:  number | null
+
+  // Adds a where condition to the query
+  where(
+    field:    string,
+    value:    unknown
+  ): QueryBuilder<T>
+
+  // Adds a where condition with operator
+  where(
+    field:    string,
+    operator: WhereCondition['operator'],
+    value:    unknown
+  ): QueryBuilder<T>
+
+  // Sets the order of results
+  orderBy(
+    field:     string,
+    direction: OrderDirection
+  ): QueryBuilder<T>
+
+  // Limits number of results returned
+  limit(n: number): QueryBuilder<T>
+
+  // Skips n results — used for pagination
+  offset(n: number): QueryBuilder<T>
+
+  // Executes and returns all matching rows
+  all(): Promise<T[]>
+
+  // Executes and returns one row by id
+  find(id: string | number): Promise<T | null>
+
+  // Returns count of matching rows
+  count(): Promise<number>
+}
+
+// Creates a query builder for a table
+function query<T = Record<string, unknown>>(
+  table: string
+): QueryBuilder<T> {
+  const conditions: WhereCondition[] = []
+  let orderField: string | null      = null
+  let orderDir:   OrderDirection     = 'asc'
+  let limitVal:   number | null      = null
+  let offsetVal:  number | null      = null
+
+  // The builder object with chainable methods
+  const builder: QueryBuilder<T> = {
+    table,
+    conditions,
+    orderField,
+    orderDir,
+    limitVal,
+    offsetVal,
+
+    where(
+      field:    string,
+      operatorOrValue: unknown,
+      value?:   unknown
+    ): QueryBuilder<T> {
+      // Two argument form: where('name', 'Kofi')
+      if (value === undefined) {
+        conditions.push({
+          field,
+          operator: '=',
+          value:    operatorOrValue,
+        })
+      } else {
+        // Three argument form: where('age', '>', 18)
+        conditions.push({
+          field,
+          operator: operatorOrValue as WhereCondition['operator'],
+          value,
+        })
+      }
+      return builder
+    },
+
+    orderBy(
+      field:     string,
+      direction: OrderDirection = 'asc'
+    ): QueryBuilder<T> {
+      orderField = field
+      orderDir   = direction
+      return builder
+    },
+
+    limit(n: number): QueryBuilder<T> {
+      limitVal = n
+      return builder
+    },
+
+    offset(n: number): QueryBuilder<T> {
+      offsetVal = n
+      return builder
+    },
+
+    async all(): Promise<T[]> {
+      console.log('[DeskForge Query] SELECT * FROM', table,
+        { conditions, orderField, orderDir, limitVal, offsetVal })
+      return []
+    },
+
+    async find(id: string | number): Promise<T | null> {
+      console.log('[DeskForge Query] SELECT * FROM', table,
+        'WHERE id =', id)
+      return null
+    },
+
+    async count(): Promise<number> {
+      console.log('[DeskForge Query] COUNT FROM', table,
+        { conditions })
+      return 0
+    },
+  }
+
+  return builder
+}
+
+export type { QueryBuilder, WhereCondition, OrderDirection }
+export { query }

package/packages/db/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/device/README.md

@@ -0,0 +1,21 @@
+# @deskforge/device
+
+Lightweight, cross-platform device APIs for DeskForge.
+
+## Features
+
+- Camera helpers: `takePhoto`, `recordVideo`, `listCameras`
+- Contacts helpers: `pickContact`, `listContacts`
+- Sensor helpers: `getSensorTypes`, `readSensor`
+- Media helpers: `pickMedia`, `pickMultiple`, `getGallery`, audio/video playback and recording
+
+## Example
+
+```ts
+import { Device, Camera, Contacts, Sensors, Media } from '@deskforge/device'
+
+const photo = await Camera.takePhoto({ width: 1280, height: 720 })
+const contacts = await Contacts.listContacts({ maxResults: 5 })
+const sensor = await Sensors.readSensor('accelerometer')
+await Media.playAudio('deskforge://placeholder/audio.mp3')
+```

package/packages/device/dist/camera.d.ts

@@ -0,0 +1,28 @@
+export type CameraFacingMode = 'user' | 'environment';
+export interface CameraOptions {
+    facingMode?: CameraFacingMode;
+    quality?: number;
+    width?: number;
+    height?: number;
+    saveToGallery?: boolean;
+}
+export interface CameraResult {
+    uri: string;
+    width: number;
+    height: number;
+    format: 'jpeg' | 'png' | 'mp4';
+    durationMs?: number;
+    timestamp: number;
+}
+declare function takePhoto(options?: CameraOptions): Promise<CameraResult>;
+declare function recordVideo(options?: CameraOptions & {
+    durationMs?: number;
+}): Promise<CameraResult>;
+declare function listCameras(): Promise<CameraFacingMode[]>;
+declare const Camera: {
+    takePhoto: typeof takePhoto;
+    recordVideo: typeof recordVideo;
+    listCameras: typeof listCameras;
+};
+export { Camera, takePhoto, recordVideo, listCameras };
+//# sourceMappingURL=camera.d.ts.map

package/packages/device/dist/camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,aAAa,CAAA;AAErD,MAAM,WAAW,aAAa;IAC5B,UAAU,CAAC,EAAE,gBAAgB,CAAA;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,CAAA;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,iBAAe,SAAS,CACtB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAUvB;AAED,iBAAe,WAAW,CACxB,OAAO,GAAE,aAAa,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,OAAO,CAAC,YAAY,CAAC,CAWvB;AAED,iBAAe,WAAW,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAGxD;AAED,QAAA,MAAM,MAAM;;;;CAIX,CAAA;AAED,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,CAAA"}

package/packages/device/dist/camera.js

@@ -0,0 +1,42 @@
+"use strict";
+// camera.ts
+// Lightweight camera API for DeskForge.
+// Provides a minimal cross-platform interface for
+// taking photos and recording video.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Camera = void 0;
+exports.takePhoto = takePhoto;
+exports.recordVideo = recordVideo;
+exports.listCameras = listCameras;
+async function takePhoto(options = {}) {
+    console.log('[DeskForge Camera] takePhoto', options);
+    return {
+        uri: 'deskforge://placeholder/photo.jpg',
+        width: options.width ?? 1280,
+        height: options.height ?? 720,
+        format: 'jpeg',
+        timestamp: Date.now(),
+    };
+}
+async function recordVideo(options = {}) {
+    console.log('[DeskForge Camera] recordVideo', options);
+    return {
+        uri: 'deskforge://placeholder/video.mp4',
+        width: options.width ?? 1280,
+        height: options.height ?? 720,
+        format: 'mp4',
+        durationMs: options.durationMs ?? 10000,
+        timestamp: Date.now(),
+    };
+}
+async function listCameras() {
+    console.log('[DeskForge Camera] listCameras');
+    return ['user', 'environment'];
+}
+const Camera = {
+    takePhoto,
+    recordVideo,
+    listCameras,
+};
+exports.Camera = Camera;
+//# sourceMappingURL=camera.js.map

package/packages/device/dist/camera.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.js","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":";AAAA,YAAY;AACZ,wCAAwC;AACxC,kDAAkD;AAClD,qCAAqC;;;AA6DpB,8BAAS;AAAE,kCAAW;AAAE,kCAAW;AAxCpD,KAAK,UAAU,SAAS,CACtB,UAAyB,EAAE;IAE3B,OAAO,CAAC,GAAG,CAAC,8BAA8B,EAAE,OAAO,CAAC,CAAA;IAEpD,OAAO;QACL,GAAG,EAAE,mCAAmC;QACxC,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,IAAI;QAC5B,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,GAAG;QAC7B,MAAM,EAAE,MAAM;QACd,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;KACtB,CAAA;AACH,CAAC;AAED,KAAK,UAAU,WAAW,CACxB,UAAmD,EAAE;IAErD,OAAO,CAAC,GAAG,CAAC,gCAAgC,EAAE,OAAO,CAAC,CAAA;IAEtD,OAAO;QACL,GAAG,EAAE,mCAAmC;QACxC,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,IAAI;QAC5B,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,GAAG;QAC7B,MAAM,EAAE,KAAK;QACb,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,KAAK;QACvC,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;KACtB,CAAA;AACH,CAAC;AAED,KAAK,UAAU,WAAW;IACxB,OAAO,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAA;IAC7C,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAChC,CAAC;AAED,MAAM,MAAM,GAAG;IACb,SAAS;IACT,WAAW;IACX,WAAW;CACZ,CAAA;AAEQ,wBAAM"}

package/packages/device/dist/contacts.d.ts

@@ -0,0 +1,19 @@
+export interface Contact {
+    id: string;
+    name: string;
+    phone?: string;
+    email?: string;
+    photoUri?: string;
+}
+export interface ContactsOptions {
+    includePhotos?: boolean;
+    maxResults?: number;
+}
+declare function pickContact(options?: ContactsOptions): Promise<Contact>;
+declare function listContacts(options?: ContactsOptions): Promise<Contact[]>;
+declare const Contacts: {
+    pickContact: typeof pickContact;
+    listContacts: typeof listContacts;
+};
+export { Contacts, pickContact, listContacts };
+//# sourceMappingURL=contacts.d.ts.map

package/packages/device/dist/contacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contacts.d.ts","sourceRoot":"","sources":["../src/contacts.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,iBAAe,WAAW,CACxB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAalB;AAED,iBAAe,YAAY,CACzB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,OAAO,EAAE,CAAC,CAapB;AAED,QAAA,MAAM,QAAQ;;;CAGb,CAAA;AAED,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,CAAA"}