@prisma-next-idb/family-idb 0.1.0

package/dist/exports/contract-ts.mjs

@@ -0,0 +1,162 @@
+import { t as validateContract } from "../validate-DL9NthnR.mjs";
+import { UNBOUND_DOMAIN_NAMESPACE_ID, crossRef } from "@prisma-next/contract/types";
+import { computeProfileHash, computeStorageHash } from "@prisma-next/contract/hashing";
+//#region src/core/contract-builder.ts
+const SCALAR_TO_CODEC_ID = {
+	String: "idb/string@1",
+	Int: "idb/int32@1",
+	Float: "idb/double@1",
+	Boolean: "idb/bool@1",
+	DateTime: "idb/date@1",
+	BigInt: "idb/bigint@1",
+	Decimal: "idb/decimal@1",
+	Json: "idb/json@1",
+	Bytes: "idb/bytes@1"
+};
+function buildFields(fields) {
+	const result = {};
+	for (const [name, spec] of Object.entries(fields)) {
+		const nullable = spec.endsWith("?");
+		const typeName = nullable ? spec.slice(0, -1) : spec;
+		const codecId = SCALAR_TO_CODEC_ID[typeName];
+		if (codecId === void 0) throw new Error(`Unknown field type "${typeName}" for field "${name}"`);
+		result[name] = {
+			nullable,
+			type: {
+				kind: "scalar",
+				codecId
+			}
+		};
+	}
+	return result;
+}
+function buildRoots(models) {
+	const roots = {};
+	for (const modelName of Object.keys(models)) {
+		const def = models[modelName];
+		roots[def.store] = crossRef(modelName);
+	}
+	return roots;
+}
+function buildStores(models) {
+	const stores = {};
+	for (const def of Object.values(models)) {
+		const indexes = {};
+		for (const [indexName, idx] of Object.entries(def.indexes ?? {})) indexes[indexName] = {
+			keyPath: idx.keyPath,
+			unique: idx.unique ?? false,
+			...idx.multiEntry !== void 0 ? { multiEntry: idx.multiEntry } : {}
+		};
+		stores[def.store] = {
+			keyPath: def.key,
+			...Object.keys(indexes).length > 0 ? { indexes } : {}
+		};
+	}
+	return stores;
+}
+function buildModels(models) {
+	const result = {};
+	for (const [modelName, def] of Object.entries(models)) {
+		const relations = {};
+		const relationsStorage = {};
+		for (const [relName, rel] of Object.entries(def.relations ?? {})) {
+			relations[relName] = {
+				to: crossRef(rel.to),
+				cardinality: rel.cardinality,
+				on: {
+					localFields: rel.on.local,
+					targetFields: rel.on.target
+				}
+			};
+			if (rel.onDelete !== void 0) relationsStorage[relName] = { onDelete: rel.onDelete };
+		}
+		const storage = Object.keys(relationsStorage).length > 0 ? {
+			storeName: def.store,
+			keyPath: def.key,
+			relations: relationsStorage
+		} : {
+			storeName: def.store,
+			keyPath: def.key
+		};
+		result[modelName] = {
+			fields: buildFields(def.fields),
+			relations,
+			storage
+		};
+	}
+	return result;
+}
+/**
+* Builds a typed IDB contract from a developer-friendly model definition.
+*
+* This is the TypeScript-first (no-emit) authoring path per ADR 006. The
+* returned contract object can be passed directly to `createIdbClient()` or
+* to `typescriptContract()` for config-file usage.
+*
+* @example
+* ```ts
+* import { defineContract } from '@prisma-next-idb/family-idb/contract-ts';
+* import idbFamily from '@prisma-next-idb/family-idb/pack';
+* import idbTarget from '@prisma-next-idb/target-idb/pack';
+*
+* export default defineContract({
+*   family: idbFamily,
+*   target: idbTarget,
+*   models: {
+*     User: {
+*       store: 'users',
+*       key: 'id',
+*       fields: { id: 'String', name: 'String?', email: 'String' },
+*       indexes: { byEmail: { keyPath: 'email', unique: true } },
+*     },
+*   },
+* });
+* ```
+*/
+function defineContract(input) {
+	const stores = buildStores(input.models);
+	const capabilities = { idb: {
+		ddlOnlyInUpgrade: true,
+		transactionalDDL: true
+	} };
+	const ns = UNBOUND_DOMAIN_NAMESPACE_ID;
+	const storageBlock = {
+		stores,
+		namespaces: { [ns]: {
+			id: ns,
+			entries: {}
+		} }
+	};
+	const storageHash = computeStorageHash({
+		target: "idb",
+		targetFamily: "idb",
+		storage: storageBlock
+	});
+	const profileHash = computeProfileHash({
+		target: "idb",
+		targetFamily: "idb",
+		capabilities
+	});
+	const storage = {
+		...storageBlock,
+		storageHash
+	};
+	const domain = { namespaces: { [ns]: { models: buildModels(input.models) } } };
+	const contract = {
+		target: "idb",
+		targetFamily: "idb",
+		roots: buildRoots(input.models),
+		domain,
+		storage,
+		capabilities,
+		extensionPacks: {},
+		meta: {},
+		profileHash
+	};
+	validateContract(contract);
+	return contract;
+}
+//#endregion
+export { defineContract };
+
+//# sourceMappingURL=contract-ts.mjs.map

package/dist/exports/contract-ts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-ts.mjs","names":[],"sources":["../../src/core/contract-builder.ts"],"sourcesContent":["import { computeProfileHash, computeStorageHash } from \"@prisma-next/contract/hashing\";\nimport type { ApplicationDomain, Contract, ContractField, CrossReference } from \"@prisma-next/contract/types\";\nimport { UNBOUND_DOMAIN_NAMESPACE_ID, crossRef } from \"@prisma-next/contract/types\";\nimport type {\n  IdbIndexDefinition,\n  IdbModelStorage,\n  IdbReferentialAction,\n  IdbStorage,\n  IdbStoreDefinition,\n} from \"@prisma-next-idb/target-idb/pack\";\nimport { validateContract } from \"./validate\";\n\n// ── Field type system ─────────────────────────────────────────────────────────\n\ntype PrismaScalarType = \"String\" | \"Int\" | \"Float\" | \"Boolean\" | \"DateTime\" | \"BigInt\" | \"Decimal\" | \"Json\" | \"Bytes\";\n\n/**\n * A field spec string: the Prisma scalar type name, optionally suffixed with\n * `?` to indicate the field is nullable (e.g. `\"String\"`, `\"Int?\"`, `\"DateTime?\"`).\n */\nexport type FieldSpec = PrismaScalarType | `${PrismaScalarType}?`;\n\nconst SCALAR_TO_CODEC_ID: Record<PrismaScalarType, string> = {\n  String: \"idb/string@1\",\n  Int: \"idb/int32@1\",\n  Float: \"idb/double@1\",\n  Boolean: \"idb/bool@1\",\n  DateTime: \"idb/date@1\",\n  BigInt: \"idb/bigint@1\",\n  Decimal: \"idb/decimal@1\",\n  Json: \"idb/json@1\",\n  Bytes: \"idb/bytes@1\",\n};\n\n// ── Input types ───────────────────────────────────────────────────────────────\n\nexport type RelationDef = {\n  readonly to: string;\n  readonly cardinality: \"1:1\" | \"1:N\" | \"N:1\";\n  readonly on: {\n    readonly local: readonly string[];\n    readonly target: readonly string[];\n  };\n  readonly onDelete?: IdbReferentialAction;\n};\n\nexport type IndexDef = {\n  readonly keyPath: string;\n  readonly unique?: boolean;\n  readonly multiEntry?: boolean;\n};\n\nexport type ModelDef = {\n  readonly store: string;\n  readonly key: string;\n  /** All scalar fields on the model. Use `\"Type\"` for non-nullable, `\"Type?\"` for nullable. */\n  readonly fields: Record<string, FieldSpec>;\n  readonly indexes?: Record<string, IndexDef>;\n  readonly relations?: Record<string, RelationDef>;\n};\n\nexport type DefineContractInput = {\n  /** Pass the default export of `@prisma-next-idb/family-idb/pack`. */\n  readonly family: { readonly familyId: \"idb\"; readonly id: string };\n  /** Pass the default export of `@prisma-next-idb/target-idb/pack`. */\n  readonly target: { readonly targetId: string; readonly id: string };\n  readonly models: Record<string, ModelDef>;\n};\n\n// ── Helper: build ContractField entries from field specs ──────────────────────\n\nfunction buildFields(fields: Record<string, FieldSpec>): Record<string, ContractField> {\n  const result: Record<string, ContractField> = {};\n  for (const [name, spec] of Object.entries(fields)) {\n    const nullable = spec.endsWith(\"?\");\n    const typeName = (nullable ? spec.slice(0, -1) : spec) as PrismaScalarType;\n    const codecId = SCALAR_TO_CODEC_ID[typeName];\n    if (codecId === undefined) {\n      throw new Error(`Unknown field type \"${typeName}\" for field \"${name}\"`);\n    }\n    result[name] = { nullable, type: { kind: \"scalar\" as const, codecId } };\n  }\n  return result;\n}\n\n// ── Helper: derive the `roots` map (storeName → model CrossReference) ─────────\n\nfunction buildRoots(models: Record<string, ModelDef>): Record<string, CrossReference> {\n  const roots: Record<string, CrossReference> = {};\n  for (const modelName of Object.keys(models)) {\n    const def = models[modelName]!;\n    // v0.12.0: roots values are CrossReference `{ namespace, model }`, not bare\n    // model-name strings. IDB has a single (unbound) namespace.\n    roots[def.store] = crossRef(modelName);\n  }\n  return roots;\n}\n\n// ── Helper: derive storage.stores from model definitions ─────────────────────\n\nfunction buildStores(models: Record<string, ModelDef>): Record<string, IdbStoreDefinition> {\n  const stores: Record<string, IdbStoreDefinition> = {};\n  for (const def of Object.values(models)) {\n    const indexes: Record<string, IdbIndexDefinition> = {};\n    for (const [indexName, idx] of Object.entries(def.indexes ?? {})) {\n      indexes[indexName] = {\n        keyPath: idx.keyPath,\n        unique: idx.unique ?? false,\n        ...(idx.multiEntry !== undefined ? { multiEntry: idx.multiEntry } : {}),\n      };\n    }\n    stores[def.store] = {\n      keyPath: def.key,\n      ...(Object.keys(indexes).length > 0 ? { indexes } : {}),\n    };\n  }\n  return stores;\n}\n\n// ── Helper: build the models section ─────────────────────────────────────────\n\ntype ContractModelEntry = {\n  readonly fields: Record<string, ContractField>;\n  readonly relations: Record<\n    string,\n    {\n      readonly to: CrossReference;\n      readonly cardinality: \"1:1\" | \"1:N\" | \"N:1\";\n      readonly on: { readonly localFields: readonly string[]; readonly targetFields: readonly string[] };\n    }\n  >;\n  readonly storage: IdbModelStorage;\n};\n\nfunction buildModels(models: Record<string, ModelDef>): Record<string, ContractModelEntry> {\n  const result: Record<string, ContractModelEntry> = {};\n  for (const [modelName, def] of Object.entries(models)) {\n    const relations: ContractModelEntry[\"relations\"] = {};\n    const relationsStorage: Record<string, { onDelete: IdbReferentialAction }> = {};\n    for (const [relName, rel] of Object.entries(def.relations ?? {})) {\n      relations[relName] = {\n        // v0.12.0: relation `to` is a CrossReference, not a bare model-name string.\n        to: crossRef(rel.to),\n        cardinality: rel.cardinality,\n        on: { localFields: rel.on.local, targetFields: rel.on.target },\n      };\n      if (rel.onDelete !== undefined) {\n        relationsStorage[relName] = { onDelete: rel.onDelete };\n      }\n    }\n    const storage: IdbModelStorage =\n      Object.keys(relationsStorage).length > 0\n        ? { storeName: def.store, keyPath: def.key, relations: relationsStorage }\n        : { storeName: def.store, keyPath: def.key };\n    result[modelName] = { fields: buildFields(def.fields), relations, storage };\n  }\n  return result;\n}\n\n// ── defineContract ────────────────────────────────────────────────────────────\n\n/**\n * Builds a typed IDB contract from a developer-friendly model definition.\n *\n * This is the TypeScript-first (no-emit) authoring path per ADR 006. The\n * returned contract object can be passed directly to `createIdbClient()` or\n * to `typescriptContract()` for config-file usage.\n *\n * @example\n * ```ts\n * import { defineContract } from '@prisma-next-idb/family-idb/contract-ts';\n * import idbFamily from '@prisma-next-idb/family-idb/pack';\n * import idbTarget from '@prisma-next-idb/target-idb/pack';\n *\n * export default defineContract({\n *   family: idbFamily,\n *   target: idbTarget,\n *   models: {\n *     User: {\n *       store: 'users',\n *       key: 'id',\n *       fields: { id: 'String', name: 'String?', email: 'String' },\n *       indexes: { byEmail: { keyPath: 'email', unique: true } },\n *     },\n *   },\n * });\n * ```\n */\nexport function defineContract(input: DefineContractInput): Contract<IdbStorage> {\n  const stores = buildStores(input.models);\n\n  // Mirror the capability surface that `prisma-next contract emit` writes\n  // into the JSON contract — keeps the two authoring paths byte-equivalent\n  // for the capabilities block. See ARCHITECTURE.md § \"Key type: capabilities\".\n  const capabilities = {\n    idb: {\n      ddlOnlyInUpgrade: true,\n      transactionalDDL: true,\n    },\n  };\n\n  // v0.12.0 (ADR 221): both planes are namespace-keyed. IDB has no namespace\n  // concept, so everything lives under the single unbound namespace.\n  const ns = UNBOUND_DOMAIN_NAMESPACE_ID;\n  const storageBlock = {\n    stores,\n    namespaces: { [ns]: { id: ns, entries: {} } },\n  };\n\n  const storageHash = computeStorageHash({\n    target: \"idb\",\n    targetFamily: \"idb\",\n    storage: storageBlock,\n  });\n\n  const profileHash = computeProfileHash({\n    target: \"idb\",\n    targetFamily: \"idb\",\n    capabilities,\n  });\n\n  const storage: IdbStorage = { ...storageBlock, storageHash };\n\n  // v0.12.0: models live under `domain.namespaces.<ns>.models`, not a top-level\n  // `models` field.\n  const domain = {\n    namespaces: { [ns]: { models: buildModels(input.models) } },\n  } as unknown as ApplicationDomain;\n\n  const contract: Contract<IdbStorage> = {\n    target: \"idb\",\n    targetFamily: \"idb\",\n    roots: buildRoots(input.models),\n    domain,\n    storage,\n    capabilities,\n    extensionPacks: {},\n    meta: {},\n    profileHash,\n  };\n\n  validateContract(contract);\n\n  return contract;\n}\n"],"mappings":"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"}

package/dist/exports/control.d.mts

@@ -0,0 +1,79 @@
+import { ControlFamilyDescriptor, ControlFamilyInstance, ControlStack } from "@prisma-next/framework-components/control";
+import { Contract } from "@prisma-next/contract/types";
+import { IdbStorage } from "@prisma-next-idb/target-idb/pack";
+
+//#region src/core/schema-ir.d.ts
+/**
+ * IndexedDB schema IR — the in-memory representation of the object store
+ * structure used by introspect(), schemaVerify(), and the manifest format.
+ *
+ * Mirrors the contract types in `@prisma-next-idb/target-idb/pack` but
+ * is independent of any versioned contract hash so it can be used as a
+ * stable internal representation.
+ */
+type IdbIndexIR = {
+  readonly keyPath: string;
+  readonly unique: boolean;
+  readonly multiEntry?: boolean;
+};
+type IdbStoreIR = {
+  readonly keyPath: string;
+  readonly autoIncrement?: boolean;
+  readonly indexes?: Record<string, IdbIndexIR>;
+};
+type IdbSchemaIR = {
+  readonly stores: Record<string, IdbStoreIR>;
+};
+//#endregion
+//#region src/core/control-instance.d.ts
+/** Fully-typed IDB control family instance returned by {@link createIdbFamilyInstance}. */
+type IdbControlFamilyInstance = ControlFamilyInstance<"idb", IdbSchemaIR>;
+//#endregion
+//#region src/core/control-descriptor.d.ts
+/**
+ * IDB family descriptor — the control-plane entry point for the IDB family.
+ *
+ * Registered in a Prisma Next config file under the `family` key:
+ * ```ts
+ * import idb from '@prisma-next-idb/family-idb/control';
+ * export default defineConfig({ family: idb, ... });
+ * ```
+ *
+ * **Responsibilities:**
+ * - Carries the {@link idbEmission} plugin used by `prisma-next contract emit`
+ *   to generate `contract.d.ts`.
+ * - Acts as a factory: `create(stack)` returns an {@link IdbControlFamilyInstance}
+ *   with domain-action methods consumed by the CLI.
+ */
+declare class IdbFamilyDescriptor implements ControlFamilyDescriptor<"idb", IdbControlFamilyInstance> {
+  readonly kind: "family";
+  readonly id = "idb";
+  readonly familyId: "idb";
+  readonly version = "0.0.1";
+  readonly emission: {
+    readonly id: "idb";
+    readonly generateStorageType: (contract: import("@prisma-next/contract/types").Contract, storageHashTypeName: string) => string;
+    readonly generateModelStorageType: (_modelName: string, model: import("@prisma-next/contract/types").ContractModel) => string;
+    readonly getFamilyImports: () => string[];
+    readonly getFamilyTypeAliases: () => string;
+    readonly getTypeMapsExpression: () => string;
+    readonly getContractWrapper: (contractBaseName: string, typeMapsName: string) => string;
+  };
+  /**
+   * Creates an {@link IdbControlFamilyInstance} for the given control stack.
+   *
+   * The instance is a plain object whose methods implement the CLI domain
+   * actions (validateContract, verify, sign, etc.).
+   */
+  create(stack: ControlStack<"idb", string>): IdbControlFamilyInstance;
+}
+//#endregion
+//#region src/core/validate.d.ts
+/** Fully-typed IDB contract after validation. */
+type IdbContract = Contract<IdbStorage>;
+//#endregion
+//#region src/exports/control.d.ts
+declare const _default: IdbFamilyDescriptor;
+//#endregion
+export { type IdbContract, type IdbControlFamilyInstance, type IdbIndexIR, type IdbSchemaIR, type IdbStoreIR, _default as default };
+//# sourceMappingURL=control.d.mts.map

package/dist/exports/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../../src/core/schema-ir.ts","../../src/core/control-instance.ts","../../src/core/control-descriptor.ts","../../src/core/validate.ts","../../src/exports/control.ts"],"mappings":";;;;;;;;;;AASA;;;KAAY,UAAA;EAAA,SACD,OAAA;EAAA,SACA,MAAA;EAAA,SACA,UAAA;AAAA;AAAA,KAGC,UAAA;EAAA,SACD,OAAA;EAAA,SACA,aAAA;EAAA,SACA,OAAA,GAAU,MAAM,SAAS,UAAA;AAAA;AAAA,KAGxB,WAAA;EAAA,SACD,MAAA,EAAQ,MAAM,SAAS,UAAA;AAAA;;;;KCmCtB,wBAAA,GAA2B,qBAAqB,QAAQ,WAAA;;;;;;ADhDpE;;;;;;;;AAGqB;AAGrB;;;cEIa,mBAAA,YAA+B,uBAAA,QAA+B,wBAAA;EAAA,SAChE,IAAA;EAAA,SACA,EAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;IAAA;;;;;;;;EFFuB;;AAAU;;;;EEU1C,MAAA,CAAO,KAAA,EAAO,YAAA,kBAA8B,wBAAA;AAAA;;;;KCzBlC,WAAA,GAAc,QAAQ,CAAC,UAAA;;;cCHiB,QAAA"}