Schema Types

type AnySchema = {
  [key: PropertyKey]: SearchableType | AnySchema
}

const schema = {
  title: 'string',
  price: 'number',
  inStock: 'boolean',
  tags: 'string[]',
  metadata: {
    category: 'string',
    rating: 'number'
  }
} satisfies AnySchema;

type Schema<TSchema> = TSchema extends AnySchema
  ? InternalTypedDocument<{
      -readonly [Key in keyof TSchema]: SchemaTypes<TSchema[Key]>
    }>
  : never

const mySchema = {
  title: 'string',
  price: 'number'
} as const;

type MyDocument = Schema<typeof mySchema>;
// Result: { id: string, title: string, price: number }

type SearchableType = ScalarSearchableType | ArraySearchableType

type ScalarSearchableType = 'string' | 'number' | 'boolean' | 'enum' | 'geopoint'

type ArraySearchableType = 'string[]' | 'number[]' | 'boolean[]' | 'enum[]' | Vector

type Vector = `vector[${number}]`

const schema = {
  title: 'string',
  embedding: 'vector[384]' // 384-dimensional vector
};

type SearchableValue = ScalarSearchableValue | ArraySearchableValue

type ScalarSearchableValue = string | number | boolean | Point

type ArraySearchableValue = string[] | number[] | boolean[] | VectorType

type Point = {
  lat: number
  lon: number
}

const location: Point = {
  lat: 40.7128,
  lon: -74.0060
};

type AnyDocument = InternalTypedDocument<any>

type InternalTypedDocument<TSchema extends object> = 
  { id: DocumentID } & TSchema & { [otherKeys: PropertyKey]: any }

type TypedDocument<T extends AnyOrama> = T['typeSchema']

import { create } from '@orama/orama';

const db = await create({
  schema: {
    title: 'string',
    price: 'number'
  }
});

type MyDoc = TypedDocument<typeof db>;
// Result: { id: string, title: string, price: number }

type SchemaTypes<Value> = 
  Value extends 'string' ? string :
  Value extends 'string[]' ? string[] :
  Value extends 'boolean' ? boolean :
  Value extends 'boolean[]' ? boolean[] :
  Value extends 'number' ? number :
  Value extends 'number[]' ? number[] :
  Value extends 'enum' ? string | number :
  Value extends 'enum[]' ? (string | number)[] :
  Value extends 'geopoint' ? Point :
  Value extends `vector[${number}]` ? number[] :
  Value extends object ? { [Key in keyof Value]: SchemaTypes<Value[Key]> } :
  never

type StringType = SchemaTypes<'string'>; // string
type NumberArrayType = SchemaTypes<'number[]'>; // number[]
type VectorType = SchemaTypes<'vector[128]'>; // number[]
type EnumType = SchemaTypes<'enum'>; // string | number

type PartialSchemaDeep<T> = {
  [K in keyof T]?: PartialSchemaDeepObject<T[K]>
}

type PartialSchemaDeepObject<T> = T extends object
  ? { [K in keyof T]?: T[K] }
  : T

type FullSchema = {
  title: string
  metadata: {
    category: string
    tags: string[]
  }
}

type PartialSchema = PartialSchemaDeep<FullSchema>;
// All properties optional:
// {
//   title?: string
//   metadata?: {
//     category?: string
//     tags?: string[]
//   }
// }

type Flatten<T extends object> = /* internal type */

type FlattenSchema<T extends AnyOrama> = Flatten<T['schema']>

type FlattenSchemaProperty<T extends AnyOrama> = 
  T['schema'] extends object ? keyof FlattenSchema<T> : string

const db = await create({
  schema: {
    title: 'string',
    metadata: {
      category: 'string',
      rating: 'number'
    }
  }
});

type FlatKeys = FlattenSchemaProperty<typeof db>;
// 'title' | 'metadata.category' | 'metadata.rating'

import { create, AnySchema, Schema } from '@orama/orama';

// Define schema
const productSchema = {
  id: 'string',
  title: 'string',
  description: 'string',
  price: 'number',
  inStock: 'boolean',
  tags: 'string[]',
  ratings: 'number[]',
  category: 'enum',
  location: 'geopoint',
  embedding: 'vector[384]',
  metadata: {
    brand: 'string',
    sku: 'string',
    weight: 'number'
  }
} satisfies AnySchema;

// Create database with typed schema
const db = await create({
  schema: productSchema
});

// TypeScript infers document type
type Product = Schema<typeof productSchema>;

// Insert with full type safety
await db.insert({
  id: '1',
  title: 'Laptop',
  description: 'High-performance laptop',
  price: 999.99,
  inStock: true,
  tags: ['electronics', 'computers'],
  ratings: [4.5, 4.8, 5.0],
  category: 'electronics',
  location: { lat: 40.7128, lon: -74.0060 },
  embedding: new Array(384).fill(0),
  metadata: {
    brand: 'TechCorp',
    sku: 'LAP-001',
    weight: 2.5
  }
});