@undefineds.co/xpod 0.4.18 → 0.4.20

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/resource-resolver/fragment-resolver.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Fragment Mode ResourceResolver
+ *
+ * In fragment mode, all records are stored in a single file (e.g., tags.ttl)
+ * Each record has a subject URI with a fragment identifier (e.g., tags.ttl#uuid)
+ *
+ * 设计原则：
+ * - base = resourcePath (如 http://pod/.data/tags.ttl)
+ * - 默认模板: {id}
+ * - 写入: id = "tags.ttl#tag-1" → relativePath = "tags.ttl#tag-1" → uri = base container + relativePath
+ * - 读取: uri - base container = "tags.ttl#tag-1" → id = "tags.ttl#tag-1"
+ */
+import type { PodTable } from '../schema';
+import type { QueryCondition } from '../query-conditions';
+import { BaseResourceResolver } from './base-resolver';
+export declare class FragmentResourceResolver extends BaseResourceResolver {
+    readonly mode: "fragment";
+    /**
+     * 获取默认模板
+     */
+    protected getDefaultTemplate(): string;
+    getContainerUrl(table: PodTable): string;
+    getResourceUrl(table: PodTable): string;
+    /**
+     * 获取表的 base URL
+     *
+     * Fragment 模式下，base 是资源文件路径（不含 fragment）
+     */
+    protected getBaseUrlForTable(table: PodTable): string;
+    getResourceUrlForSubject(subjectUri: string): string;
+    resolveSelectSources(table: PodTable, containerUrl: string, condition?: QueryCondition, _listContainer?: (url?: string) => Promise<string[]>): Promise<string[]>;
+    resolveSubjectsForMutation(table: PodTable, condition: QueryCondition, findSubjects: (resourceUrl: string) => Promise<string[]>, _listContainer: () => Promise<string[]>): Promise<string[]>;
+}
+//# sourceMappingURL=fragment-resolver.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/resource-resolver/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ResourceResolver Module
+ *
+ * Provides abstraction for fragment vs document mode resource resolution
+ */
+export type { ResourceResolver, ResourceResolverFactory } from './types';
+export { BaseResourceResolver } from './base-resolver';
+export { FragmentResourceResolver } from './fragment-resolver';
+export { DocumentResourceResolver } from './document-resolver';
+export { ResourceResolverFactoryImpl, getResourceMode } from './factory';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/resource-resolver/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ResourceResolver Interface
+ *
+ * Abstracts the difference between fragment mode and document mode
+ * for resource URL resolution and listing.
+ */
+import type { PodTable } from '../schema';
+import type { QueryCondition } from '../query-conditions';
+export interface ResourceResolver {
+    /**
+     * Get the mode this resolver handles
+     */
+    readonly mode: 'fragment' | 'document';
+    /**
+     * Get the container URL for a table
+     */
+    getContainerUrl(table: PodTable): string;
+    /**
+     * Get the default resource URL for a table (used for fragment mode reads)
+     */
+    getResourceUrl(table: PodTable): string;
+    /**
+     * Resolve subject URI for a record
+     */
+    resolveSubject(table: PodTable, record: Record<string, any>, index?: number): string;
+    /**
+     * Parse id from a subject URI
+     */
+    parseId(table: PodTable, subjectUri: string): string;
+    /**
+     * Get the resource URL that contains a given subject
+     */
+    getResourceUrlForSubject(subjectUri: string): string;
+    /**
+     * Extract id values from a query condition
+     */
+    extractIdValues(condition: QueryCondition | undefined): string[];
+    /**
+     * Resolve resource URLs to query for a SELECT operation
+     * - With id condition: returns specific resource URLs
+     * - Without id condition: returns all resources to scan
+     */
+    resolveSelectSources(table: PodTable, containerUrl: string, condition?: QueryCondition, listContainer?: (url?: string) => Promise<string[]>): Promise<string[]>;
+    /**
+     * Resolve subjects for UPDATE/DELETE operations
+     * - With id condition: resolves subjects directly from ids
+     * - Without id condition: needs to query resources to find subjects
+     */
+    resolveSubjectsForMutation(table: PodTable, condition: QueryCondition, findSubjects: (resourceUrl: string) => Promise<string[]>, listContainer: () => Promise<string[]>): Promise<string[]>;
+}
+export interface ResourceResolverFactory {
+    /**
+     * Get the appropriate resolver for a table based on its configuration
+     */
+    getResolver(table: PodTable): ResourceResolver;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/runtime/pod-runtime.d.ts

@@ -0,0 +1,60 @@
+import type { SolidAuthSession } from '../pod-dialect';
+export declare class PodRuntime {
+    private session;
+    private webId;
+    private podUrl;
+    private storageUrl;
+    private storageResolvedAt;
+    private connected;
+    private wrappedFetch;
+    private requestIdSupported;
+    private explicitPodUrl;
+    /** Storage 缓存过期时间，默认 5 分钟 */
+    private storageTTL;
+    constructor(options: {
+        session: SolidAuthSession;
+        webId: string;
+        podUrl?: string;
+        storageTTL?: number;
+    });
+    /**
+     * 检测服务器是否允许 X-Request-ID header (通过 CORS preflight)
+     * 使用原生 fetch 发送最干净的 OPTIONS 请求
+     */
+    private detectRequestIdSupport;
+    /**
+     * 创建包装的 fetch 函数，自动添加 X-Request-ID header
+     */
+    private createWrappedFetch;
+    getSession(): SolidAuthSession;
+    /**
+     * 获取 fetch 函数（如果服务器支持，会自动添加 X-Request-ID）
+     */
+    getFetch(): typeof fetch;
+    getWebId(): string;
+    getPodUrl(): string;
+    /**
+     * 获取缓存的 storage URL (从 profile 的 pim:storage 读取)
+     * 如果没有显式配置，返回 null
+     */
+    getStorageUrl(): string | null;
+    /**
+     * 检查 storage 缓存是否过期
+     */
+    isStorageExpired(): boolean;
+    /**
+     * 获取 Pod URL，如果 storage 缓存过期则自动刷新
+     * 用于需要确保最新 storage 的场景
+     */
+    getPodUrlWithRefresh(): Promise<string>;
+    /**
+     * 强制刷新 storage URL（从 profile 重新读取）
+     * 用于 storage 配置变更后的场景
+     */
+    refreshStorage(): Promise<string | null>;
+    setPodUrl(url: string): void;
+    isConnected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+//# sourceMappingURL=pod-runtime.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/schema/columns.d.ts

@@ -0,0 +1,74 @@
+import { entityKind } from 'drizzle-orm';
+import { ColumnBuilderDataType, PodColumnOptions, NamespaceConfig, RdfTermInput } from './defs';
+export declare class ColumnBuilder<TType extends ColumnBuilderDataType, TElement extends ColumnBuilderDataType | null = null, TNotNull extends boolean = false, THasDefault extends boolean = false> {
+    readonly name: string;
+    readonly dataType: TType;
+    options: PodColumnOptions;
+    private _predicateUri?;
+    readonly elementType: TElement;
+    constructor(name: string, dataType: TType, options?: PodColumnOptions, predicate?: string, elementType?: TElement);
+    formatValue(value: any): string | string[];
+    private formatSingleValue;
+    parseValue(rdfValue: string, datatypeIri?: string): any;
+    private parseSingleValue;
+    primaryKey(): ColumnBuilder<TType, TElement, true, THasDefault>;
+    notNull(): ColumnBuilder<TType, TElement, true, THasDefault>;
+    predicate(uri: RdfTermInput): ColumnBuilder<TType, TElement, TNotNull, THasDefault>;
+    default(value: unknown): ColumnBuilder<TType, TElement, TNotNull, true>;
+    defaultNow(): ColumnBuilder<TType, TElement, TNotNull, true>;
+    inverse(value?: boolean): ColumnBuilder<TType, TElement, TNotNull, THasDefault>;
+    link(target: string | any): ColumnBuilder<TType, TElement, TNotNull, THasDefault>;
+    array(): ColumnBuilder<'array', TType, TNotNull, THasDefault>;
+    getPredicateUri(): string | undefined;
+}
+export declare abstract class PodColumnBase<TType extends ColumnBuilderDataType = ColumnBuilderDataType, TNotNull extends boolean = false, THasDefault extends boolean = false, TElement extends ColumnBuilderDataType | null = null> {
+    name: string;
+    readonly dataType: TType;
+    options: PodColumnOptions;
+    tableName?: string | undefined;
+    static readonly [entityKind] = "PodColumn";
+    readonly _traits: [TNotNull, THasDefault, TElement];
+    constructor(name: string, dataType: TType, options?: PodColumnOptions, tableName?: string | undefined);
+    table?: any;
+    relationName?: string;
+    getPredicate(tableNamespace?: NamespaceConfig): string;
+    isLink(): boolean;
+    getLinkTarget(): string | undefined;
+    getLinkTableName(): string | undefined;
+    getLinkTable(): any | undefined;
+    primaryKey(): this;
+    notNull(): this;
+    default(value: unknown): this;
+    predicate(uri: RdfTermInput): this;
+    link(target: string | any): this;
+    inverse(value?: boolean): this;
+    isInverse(): boolean;
+    formatValue(value: any): string | string[];
+    protected formatSingleValue(value: any): string;
+}
+export declare class PodStringColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'string', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodIntegerColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'integer', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodBooleanColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'boolean', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodDateTimeColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'datetime', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodJsonColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'json', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodObjectColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'object', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodUriColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'uri', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodArrayColumn<TElement extends ColumnBuilderDataType = ColumnBuilderDataType, TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'array', TNotNull, THasDefault, TElement> {
+    readonly elementType: TElement;
+    constructor(name: string, elementType: TElement, options?: PodColumnOptions);
+}
+//# sourceMappingURL=columns.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/schema/defs.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Basic definitions and interfaces for Drizzle Solid Schema.
+ */
+export declare const generateNanoId: (size?: number) => string;
+export interface NamespaceConfig {
+    prefix: string;
+    uri: string;
+}
+export type ColumnBuilderDataType = 'string' | 'integer' | 'datetime' | 'boolean' | 'json' | 'object' | 'array' | 'uri';
+export type RdfTermInput = string | {
+    value: string;
+} | {
+    term?: {
+        value: string;
+    };
+};
+export declare const hasStringValue: (input: unknown) => input is {
+    value: string;
+};
+export declare const hasTermValue: (input: unknown) => input is {
+    term: {
+        value: string;
+    };
+};
+export declare const resolveTermIri: (input: RdfTermInput) => string;
+export interface PodColumnOptions {
+    primaryKey?: boolean;
+    required?: boolean;
+    defaultValue?: unknown | ((key?: string, row?: Record<string, unknown>) => unknown);
+    predicate?: string;
+    linkTarget?: string;
+    linkTableName?: string;
+    linkTable?: any;
+    notNull?: boolean;
+    baseType?: ColumnBuilderDataType;
+    isArray?: boolean;
+    inverse?: boolean;
+}
+export interface SolidSession {
+    info: {
+        isLoggedIn: boolean;
+        webId?: string;
+        sessionId?: string;
+    };
+    fetch: typeof globalThis.fetch;
+}
+export interface HookContext {
+    session: SolidSession;
+    table: any;
+    db: any;
+}
+export interface TableHooks {
+    afterInsert?: (ctx: HookContext, record: Record<string, unknown>) => Promise<void>;
+    afterUpdate?: (ctx: HookContext, record: Record<string, unknown>, changes: Record<string, unknown>) => Promise<void>;
+    afterDelete?: (ctx: HookContext, record: Record<string, unknown>) => Promise<void>;
+}
+export interface PodTableOptions {
+    base?: string;
+    sparqlEndpoint?: string;
+    type: RdfTermInput;
+    namespace?: NamespaceConfig;
+    typeIndex?: 'private' | 'public';
+    saiRegistryPath?: string;
+    subClassOf?: RdfTermInput | RdfTermInput[];
+    /**
+     * @deprecated Prefer exact-id mode: omit this field and use base-relative
+     * resource ids such as "post-1.ttl" or "chat/messages.ttl#msg-1".
+     * Keep subjectTemplate only for legacy layouts or explicit compatibility.
+     */
+    subjectTemplate?: string;
+    resourceMode?: 'ldp' | 'sparql';
+    autoRegister?: boolean;
+    hooks?: TableHooks;
+}
+export type SolidSchemaOptions = Omit<PodTableOptions, 'base' | 'hooks'>;
+export interface InstantiateTableOptions extends Omit<PodTableOptions, 'type' | 'base'> {
+    base: string;
+}
+export interface PodColumnMapping {
+    column: string;
+    predicate: string;
+    kind: 'datatype' | 'object';
+    datatype?: string;
+    linkTarget?: string;
+    isArray?: boolean;
+    inverse?: boolean;
+}
+export interface PodTableMapping {
+    name: string;
+    type: string;
+    /**
+     * @deprecated Present only for legacy/explicit template layouts.
+     * New resources should use exact base-relative ids.
+     */
+    subjectTemplate?: string;
+    namespace?: NamespaceConfig;
+    subClassOf?: string[];
+    columns: Record<string, PodColumnMapping>;
+    relations?: Record<string, any>;
+}
+//# sourceMappingURL=defs.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/schema/factories.d.ts

@@ -0,0 +1,29 @@
+import { PodColumnOptions } from './defs';
+import { ColumnBuilder, PodStringColumn } from './columns';
+export declare function boolean(name: string, options?: PodColumnOptions): ColumnBuilder<'boolean'>;
+export declare function timestamp(name: string, options?: PodColumnOptions): ColumnBuilder<'datetime'>;
+export declare function json(name: string, options?: PodColumnOptions): ColumnBuilder<'json'>;
+export declare function object(name: string, options?: PodColumnOptions): ColumnBuilder<'object'>;
+export declare function uri(name: string, options?: PodColumnOptions): ColumnBuilder<'uri'>;
+export declare function iri(name: string, options?: PodColumnOptions): ColumnBuilder<'uri'>;
+export declare function id(name?: string, options?: PodColumnOptions): PodStringColumn;
+export declare function string(name: string, options?: PodColumnOptions): ColumnBuilder<'string'>;
+export declare function int(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function integer(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function date(name: string, options?: PodColumnOptions): ColumnBuilder<'datetime'>;
+export declare function datetime(name: string, options?: PodColumnOptions): ColumnBuilder<'datetime'>;
+export declare function text(name: string, options?: PodColumnOptions): ColumnBuilder<'string'>;
+export declare function varchar(name: string, options?: PodColumnOptions): ColumnBuilder<'string'>;
+export declare function char(name: string, options?: PodColumnOptions): ColumnBuilder<'string'>;
+export declare function bigint(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function smallint(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function tinyint(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function mediumint(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function serial(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function real(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function decimal(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function numeric(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function float(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function double(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function jsonb(name: string, options?: PodColumnOptions): ColumnBuilder<'json'>;
+//# sourceMappingURL=factories.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/schema/index.d.ts

@@ -0,0 +1,9 @@
+export * from './defs';
+export * from './columns';
+export * from './types';
+export * from './factories';
+export * from './solid-schema';
+export * from './pod-table';
+export * from './relations';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/schema/pod-table.d.ts

@@ -0,0 +1,118 @@
+import { entityKind } from 'drizzle-orm';
+import { NamespaceConfig, PodTableOptions, PodTableMapping, TableHooks } from './defs';
+import { PodColumnBase } from './columns';
+import { InferTableData, InferInsertData, InferUpdateData, ColumnInput, ResolvedColumns } from './types';
+import { SolidSchema } from './solid-schema';
+import { type PodResourceReference, type PodResourceTarget } from '../resource-reference';
+/**
+ * PodTable with columns accessible as direct properties.
+ * This type combines PodTable with its column definitions.
+ */
+export type PodTableWithColumns<TColumns extends Record<string, PodColumnBase<any, any, any, any>>> = PodTable<TColumns> & TColumns;
+/**
+ * Resource-narrative alias for shared models. Table naming remains for
+ * drizzle-compatible internals; model packages should expose resources.
+ */
+export type PodResource<TColumns extends Record<string, PodColumnBase<any, any, any, any>> = Record<string, PodColumnBase<any, any, any, any>>> = PodTable<TColumns>;
+export type PodResourceWithColumns<TColumns extends Record<string, PodColumnBase<any, any, any, any>>> = PodTableWithColumns<TColumns>;
+export interface PodTableInitializer {
+    registerTable(table: PodTable<any>): Promise<void>;
+}
+export declare class PodTable<TColumns extends Record<string, PodColumnBase<any, any, any, any>> = Record<string, PodColumnBase<any, any, any, any>>> {
+    static readonly [entityKind] = "PodTable";
+    config: {
+        name: string;
+        base: string;
+        type: string;
+        namespace?: NamespaceConfig;
+        typeIndex?: 'private' | 'public';
+        saiRegistryPath?: string;
+        subClassOf?: string[];
+        /**
+         * @deprecated Present only when a legacy/explicit subjectTemplate is set.
+         * Omitted means exact-id mode.
+         */
+        subjectTemplate?: string;
+        containerPath?: string;
+        resourcePath?: string;
+        autoRegister?: boolean;
+        hooks?: TableHooks;
+    };
+    mapping: PodTableMapping;
+    relations?: Record<string, any>;
+    private resourcePath;
+    private containerPath;
+    private initialized;
+    private subjectTemplate?;
+    private hasCustomSubjectTemplate;
+    private resourceMode?;
+    private sparqlEndpoint?;
+    private registerTypeIndexEnabled;
+    private parentClasses;
+    columns: TColumns;
+    readonly $inferSelect: InferTableData<PodTable<TColumns>>;
+    readonly $inferInsert: InferInsertData<PodTable<TColumns>>;
+    readonly $inferUpdate: InferUpdateData<PodTable<TColumns>>;
+    readonly _: {
+        readonly brand: 'Table';
+        readonly config: PodTableOptions;
+        readonly name: string;
+        readonly schema: string | undefined;
+        readonly columns: TColumns;
+        readonly inferSelect: InferTableData<PodTable<TColumns>>;
+        readonly inferInsert: InferInsertData<PodTable<TColumns>>;
+        readonly inferUpdate: InferUpdateData<PodTable<TColumns>>;
+    };
+    constructor(name: string, columns: TColumns, options: PodTableOptions);
+    getContainerPath(): string;
+    getType(): string;
+    getRdfClass(): string;
+    getNamespace(): NamespaceConfig | undefined;
+    /**
+     * @deprecated subjectTemplate is compatibility-only. Omitted means exact-id mode.
+     */
+    getSubjectTemplate(): string | undefined;
+    buildId(target: PodResourceTarget): string;
+    buildIri(webIdOrPodUrl: string, target: PodResourceTarget): string;
+    buildIriForDatabase(database: unknown, target: PodResourceTarget): string;
+    resolveIriForDatabase(database: unknown, target: PodResourceTarget | null | undefined): string | null;
+    parseRef(ref: string | null | undefined): PodResourceReference | null;
+    extractTemplateValue(ref: string | null | undefined, field?: string): string | null;
+    hasCustomTemplate(): boolean;
+    getSubClassOf(): string[];
+    getMapping(): PodTableMapping;
+    get $schema(): SolidSchema<TColumns>;
+    resolveUri(id: string): string;
+    private resolveBase;
+    private normalizeBaseInput;
+    private normalizeResourcePath;
+    private deriveContainerPath;
+    private ensureTrailingSlash;
+    getResourcePath(): string;
+    getResourceMode(): 'ldp' | 'sparql' | undefined;
+    getSparqlEndpoint(): string | undefined;
+    shouldRegisterTypeIndex(): boolean;
+    init(initializer: PodTableInitializer): Promise<void>;
+    isInitialized(): boolean;
+    markInitialized(initialized?: boolean): void;
+    setBase(base: string): void;
+    setSubjectTemplate(template: string): void;
+    setSparqlEndpoint(endpoint: string): void;
+    getColumns(): TColumns;
+    getColumn<TKey extends keyof TColumns>(name: TKey): TColumns[TKey];
+    getColumn(name: string): PodColumnBase | undefined;
+    hasColumn(name: string): boolean;
+    private resolveSubjectTemplate;
+    /**
+     * No subjectTemplate means exact-id mode: public id is already a
+     * base-relative resource id. Callers must pass subjectTemplate explicitly
+     * for document/fragment template behavior.
+     */
+    private buildTableMapping;
+    private buildColumnMapping;
+    private inferColumnDatatype;
+    private normalizeParents;
+}
+export declare function alias<TColumns extends Record<string, PodColumnBase<any, any, any, any>>>(table: PodTableWithColumns<TColumns>, aliasName: string): PodTableWithColumns<TColumns>;
+export declare function podTable<TName extends string, TColumns extends Record<string, ColumnInput>>(name: TName, columns: TColumns, options: PodTableOptions): PodTableWithColumns<ResolvedColumns<TColumns>>;
+//# sourceMappingURL=pod-table.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/schema/relations.d.ts

@@ -0,0 +1,26 @@
+import { PodTable } from './pod-table';
+import { SolidSchema } from './solid-schema';
+import { PodColumnBase } from './columns';
+export type RelationKind = 'one' | 'many';
+export type DiscoverFunction<TParent = any> = (parent: TParent) => string | string[] | undefined;
+export interface RelationDefinition {
+    type: RelationKind;
+    table: PodTable<any> | SolidSchema<any>;
+    fields?: PodColumnBase[];
+    references?: PodColumnBase[];
+    relationName?: string;
+    discover?: DiscoverFunction;
+    isFederated?: boolean;
+}
+export type RelationBuilder = {
+    one: <T extends PodTable<any> | SolidSchema<any>>(table: T, options?: RelationOptions<T>) => RelationDefinition;
+    many: <T extends PodTable<any> | SolidSchema<any>>(table: T, options?: RelationOptions<T>) => RelationDefinition;
+};
+export interface RelationOptions<T = PodTable<any> | SolidSchema<any>> {
+    fields?: PodColumnBase[];
+    references?: PodColumnBase[];
+    relationName?: string;
+    discover?: DiscoverFunction;
+}
+export declare function relations<TTable extends PodTable<any>>(table: TTable, builder: (helpers: RelationBuilder) => Record<string, RelationDefinition>): Record<string, RelationDefinition>;
+//# sourceMappingURL=relations.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/schema/solid-schema.d.ts

@@ -0,0 +1,22 @@
+import { NamespaceConfig, SolidSchemaOptions, InstantiateTableOptions } from './defs';
+import { PodColumnBase } from './columns';
+import { ColumnInput, MergedColumns, ResolvedColumns } from './types';
+import { PodTableWithColumns } from './pod-table';
+export declare class SolidSchema<TColumns extends Record<string, PodColumnBase<any, any, any, any>> = Record<string, PodColumnBase<any, any, any, any>>> {
+    readonly columns: TColumns;
+    readonly options: SolidSchemaOptions;
+    readonly $kind: "SolidSchema";
+    readonly namespace?: NamespaceConfig;
+    /**
+     * @deprecated subjectTemplate is compatibility-only. Prefer exact-id layouts.
+     */
+    readonly subjectTemplate?: string;
+    readonly subClassOf?: string[];
+    constructor(columns: TColumns, options: SolidSchemaOptions);
+    table(name: string, options: InstantiateTableOptions): PodTableWithColumns<TColumns>;
+    extend<TChildColumns extends Record<string, ColumnInput>>(columns: TChildColumns, options: Omit<SolidSchemaOptions, 'subClassOf'>): SolidSchema<MergedColumns<TColumns, ResolvedColumns<TChildColumns>>>;
+    get type(): string;
+}
+export declare function solidSchema<TColumns extends Record<string, ColumnInput>>(columns: TColumns, options: SolidSchemaOptions): SolidSchema<ResolvedColumns<TColumns>>;
+export declare function isSolidSchema(target: unknown): target is SolidSchema<any>;
+//# sourceMappingURL=solid-schema.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/schema/types.d.ts

@@ -0,0 +1,45 @@
+import { ColumnBuilderDataType } from './defs';
+import { PodColumnBase, PodStringColumn, PodIntegerColumn, PodBooleanColumn, PodDateTimeColumn, PodJsonColumn, PodObjectColumn, PodUriColumn, PodArrayColumn, ColumnBuilder } from './columns';
+export type ColumnValueType<T extends ColumnBuilderDataType> = T extends 'string' ? string : T extends 'integer' ? number : T extends 'boolean' ? boolean : T extends 'datetime' ? Date : T extends 'json' ? unknown : T extends 'object' ? Record<string, unknown> : T extends 'uri' ? string : T extends 'array' ? unknown[] : unknown;
+type ExtractNotNull<T extends PodColumnBase> = T extends PodColumnBase<any, infer TNotNull, any, any> ? TNotNull : false;
+type ExtractHasDefault<T extends PodColumnBase> = T extends PodColumnBase<any, any, infer THasDefault, any> ? THasDefault : false;
+type ColumnIsRequiredForInsert<T extends PodColumnBase> = ExtractNotNull<T> extends true ? ExtractHasDefault<T> extends true ? false : true : false;
+type ColumnAllowsNull<T extends PodColumnBase> = ExtractNotNull<T> extends true ? false : true;
+export type InferColumnType<T extends PodColumnBase> = T extends PodArrayColumn<infer ElementType, any, any> ? ColumnValueType<ElementType>[] : ColumnValueType<T['dataType']>;
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type InferTableData<TTable extends {
+    columns: Record<string, PodColumnBase<any, any, any, any>>;
+}> = Simplify<{
+    [K in keyof TTable['columns']]: InferColumnType<TTable['columns'][K]>;
+}>;
+type InsertRequiredColumns<TTable extends {
+    columns: Record<string, PodColumnBase<any, any, any, any>>;
+}> = {
+    [K in keyof TTable['columns'] as ColumnIsRequiredForInsert<TTable['columns'][K]> extends true ? K : never]: InferColumnType<TTable['columns'][K]>;
+};
+type InsertOptionalColumns<TTable extends {
+    columns: Record<string, PodColumnBase<any, any, any, any>>;
+}> = {
+    [K in keyof TTable['columns'] as ColumnIsRequiredForInsert<TTable['columns'][K]> extends true ? never : K]?: InferColumnType<TTable['columns'][K]>;
+};
+export type InferInsertData<TTable extends {
+    columns: Record<string, PodColumnBase<any, any, any, any>>;
+}> = Simplify<InsertRequiredColumns<TTable> & InsertOptionalColumns<TTable>>;
+type UpdateColumnValue<T extends PodColumnBase<any, any, any, any>> = ColumnAllowsNull<T> extends true ? InferColumnType<T> | null : InferColumnType<T>;
+export type InferUpdateData<TTable extends {
+    columns: Record<string, PodColumnBase<any, any, any, any>>;
+}> = Simplify<{
+    [K in keyof TTable['columns']]?: UpdateColumnValue<TTable['columns'][K]>;
+}>;
+export type MergedColumns<TParent extends Record<string, PodColumnBase<any, any, any, any>>, TChild extends Record<string, PodColumnBase<any, any, any, any>>> = Simplify<{
+    [K in keyof TParent | keyof TChild]: K extends keyof TChild ? TChild[K] : K extends keyof TParent ? TParent[K] : never;
+}>;
+export type ColumnInput = PodColumnBase | ColumnBuilder<ColumnBuilderDataType, ColumnBuilderDataType | null, boolean, boolean>;
+export type ResolveColumn<T> = T extends ColumnBuilder<'string', any, infer TNotNull, infer THasDefault> ? PodStringColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'integer', any, infer TNotNull, infer THasDefault> ? PodIntegerColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'boolean', any, infer TNotNull, infer THasDefault> ? PodBooleanColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'datetime', any, infer TNotNull, infer THasDefault> ? PodDateTimeColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'json', any, infer TNotNull, infer THasDefault> ? PodJsonColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'object', any, infer TNotNull, infer THasDefault> ? PodObjectColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'uri', any, infer TNotNull, infer THasDefault> ? PodUriColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'array', infer TElement, infer TNotNull, infer THasDefault> ? PodArrayColumn<TElement extends ColumnBuilderDataType ? TElement : ColumnBuilderDataType, TNotNull, THasDefault> : T extends PodColumnBase ? T : PodColumnBase;
+export type ResolvedColumns<T extends Record<string, ColumnInput>> = {
+    [K in keyof T]: ResolveColumn<T[K]>;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/schema/utils.d.ts

@@ -0,0 +1,15 @@
+import { ColumnBuilderDataType } from './defs';
+import { ColumnBuilder, PodColumnBase } from './columns';
+import { ColumnInput } from './types';
+import type { SolidSchema } from './solid-schema';
+/**
+ * 验证子类列不能修改父类的 predicate
+ * @internal
+ */
+export declare function validateColumnOverride(childColumn: ColumnBuilder<ColumnBuilderDataType, ColumnBuilderDataType | null, boolean, boolean>, parentColumn: PodColumnBase<ColumnBuilderDataType, boolean, boolean, ColumnBuilderDataType | null>, columnName: string): void;
+/**
+ * 合并父子 schema 的列定义
+ * @internal
+ */
+export declare function mergeSchemaColumns<TChildColumns extends Record<string, ColumnInput>>(parentSchema: SolidSchema<Record<string, PodColumnBase<ColumnBuilderDataType, boolean, boolean, ColumnBuilderDataType | null>>>, childColumns: TChildColumns): Record<string, PodColumnBase<ColumnBuilderDataType, boolean, boolean, ColumnBuilderDataType | null> | ColumnInput>;
+//# sourceMappingURL=utils.d.ts.map