@uipath/packager-tool-datafabric 1.204.0 → 1.205.0-preview.258

package/dist/missing-path.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Whether a filesystem error means the path is not there, as opposed to being
+ * there and unreadable (EACCES, EIO, ELOOP).
+ *
+ * The distinction is the whole point: a missing project or resource is a
+ * state a command can act on, while an unreadable one is not evidence of
+ * absence. Treating both as "missing" let an ownership scan miss a sibling it
+ * could not read, and a `--force` delete then removed a resource that sibling
+ * still declares. `PathNotFound` is the in-memory filesystem's spelling.
+ */
+export declare function isMissingPathError(error: unknown): boolean;
+/** A Node filesystem error (`EACCES`, `EIO`, `ENOSPC`, …): something the disk
+ *  said, as opposed to content that failed to parse. */
+export declare function isFilesystemError(error: unknown): boolean;
+/**
+ * The disk refusing a path that may well be there (EACCES, EIO, ELOOP): never
+ * evidence of absence, and never a parse problem.
+ */
+export declare function isUnreadablePathError(error: unknown): boolean;

package/dist/pack/constants.d.ts

@@ -15,4 +15,7 @@ export declare const PACK_DIAGNOSTIC_CODES: {
     /** The project has entities but no parent solution, so their
      *  solution-relative resource pointers cannot resolve. */
     readonly noParentSolution: "NO_PARENT_SOLUTION";
+    /** A directory between the project and its `.uipx` could not be read, so
+     *  the owning solution — and the stubs' pointers — cannot be trusted. */
+    readonly solutionRootUnreadable: "SOLUTION_ROOT_UNREADABLE";
 };

package/dist/pack/verify-pair.d.ts

@@ -24,5 +24,18 @@ export type PairResult = {
  * `Name` couples back to the stub. Reads only.
  */
 export declare function verifyPair(stubFile: string, solutionDir: string, fs: IFileSystem): Promise<PairResult>;
-/** The owning solution dir, or undefined when outside any solution. */
+/**
+ * The owning solution dir, or undefined when outside any solution.
+ *
+ * An unreadable directory (EACCES, EIO) may be the real solution root, so a
+ * `.uipx` found ABOVE one is not trusted: the walk throws the read error
+ * rather than hand back an ancestor's solution for a mutating command to act
+ * on. With no `.uipx` above it, the walk ends as "outside any solution" as
+ * before — an unlistable `/home` (0711) must not turn every command run
+ * outside a solution into a raw EACCES. A code-less error (the browser's
+ * in-memory filesystem) reads as missing.
+ *
+ * @throws the read error in that one case. Earlier versions never threw and
+ * returned the ancestor instead — callers outside this package must handle it.
+ */
 export declare function findSolutionRoot(startDir: string, fs: IFileSystem): Promise<string | undefined>;

package/dist/resource/local-entities.d.ts

@@ -0,0 +1,14 @@
+import type { IFileSystem, LocalEntityRef } from "@uipath/solutionpackager-tool-core";
+/** The shape lives in the packager core, shared with the Flow packager that
+ *  binds nodes to these. Re-exported so callers keep importing it from here. */
+export type { LocalEntityRef };
+/**
+ * The entities the solution enclosing `flowFilePath` authors locally, keyed by
+ * lower-cased name (names are solution-wide unique that way). Empty outside a
+ * solution. Referenced platform entities are skipped: not the solution's to
+ * wire.
+ *
+ * Here, beside the layout it reads, so any tool can hand it to the Flow pack
+ * gate without importing another tool (Hard Rule 19).
+ */
+export declare function readSolutionInlineEntities(fs: IFileSystem, flowFilePath: string): Promise<Map<string, LocalEntityRef>>;

package/dist/resource/unified-resource-file.d.ts

@@ -36,6 +36,27 @@ export declare const ENTITY_RESOURCE_TYPE = "native";
 export declare const ENTITY_RESOURCE_API_VERSION = "dataservice.uipath.com/v2";
 export declare const ENTITY_RESOURCE_DOC_VERSION = "1.0.0";
 export declare const SOLUTION_FOLDER = "solution_folder";
+/**
+ * Directory segments under `resources/<SOLUTION_FOLDER>/` that home an entity
+ * definition.
+ *
+ * DERIVED from the kind and type above, never written out as its own literal:
+ * the resource tree is partitioned by `<kind>/<type>`, so a directory that
+ * disagrees with the `kind`/`type` inside the file it holds is a directory the
+ * platform will move. `resource-casing.ts` in solution-sdk recomputes this path
+ * from the resource's own fields through `lowerFirstChar` and relocates the
+ * file to match — and on a case-sensitive filesystem a stale case-variant left
+ * behind carries the same resource key, which fails the next load with "Node
+ * already added to the graph".
+ *
+ * So the casing is not a style choice. Server-sourced resources arrive
+ * capitalized (`Entity/Native`, and `NativeEntity` while that server bug was
+ * live) and are normalized down to this form; they are inputs, not the target.
+ * The VS Code extension keys its delete guard and name-collision scan off
+ * `ENTITY_RESOURCE_KIND` directly, so anything written elsewhere is invisible
+ * to both.
+ */
+export declare const ENTITY_RESOURCE_DIR = "entity/native";
 /** Solution-root-relative path of an entity's resource file. One convention
  *  shared by scaffolding, the editor's pairing and pack. */
 export declare function entityResourcePath(entityName: string): string;

package/dist/schema/author-field.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Build an authored {@link EntityField} from the same field-type vocabulary
+ * `uip df entities create` takes, so one payload shape serves both authors.
+ *
+ * Two vocabularies meet here. The CLI and the SDK speak
+ * `EntityFieldDataType` (`STRING`, `DECIMAL`, `BOOLEAN`, …) in camelCase API
+ * bodies; the authored document speaks entity-modeler's
+ * `(FieldDisplayType, SqlTypeName)` pairs in PascalCase. This module is the
+ * translation, and it is deliberately the only place that knows both — the
+ * shapes differ for the same reason `@uipath/common/entity-name-rules` is
+ * shape-agnostic.
+ *
+ * The emitted field mirrors what Studio Web's modeller writes for a custom
+ * field, nulls included, so an entity authored here and one authored there are
+ * the same document.
+ */
+import { type EntityField } from "@uipath/entity-modeler/schema";
+/** A field as a caller describes it — the `addFields` entry shape, minus the
+ *  keys only a relationship or choice-set field needs. */
+export interface AuthoredFieldSpec {
+    name: string;
+    /** An `EntityFieldDataType` name. See {@link AUTHORABLE_FIELD_TYPES}. */
+    type: string;
+    displayName?: string;
+    description?: string;
+    isRequired?: boolean;
+    isUnique?: boolean;
+    /** NVARCHAR / MULTILINE character cap; MULTILINE_MAX counts BYTES. */
+    lengthLimit?: number | null;
+    /** DECIMAL and AUTO_NUMBER only. */
+    decimalPrecision?: number | null;
+    maxValue?: number | null;
+    minValue?: number | null;
+    /**
+     * What this module writes is a STRING for every field type — a DECIMAL
+     * default is `"0"` and a BOOLEAN one is `"true"` — and a caller must
+     * supply it that way. Typed as `EntityField`'s own `DefaultValue`
+     * (`string | boolean | null`) because an update re-supplies the stored
+     * value, and a document written elsewhere may hold a boolean; that
+     * round-trips unchanged. Null clears it.
+     */
+    defaultValue?: EntityField["DefaultValue"];
+}
+/** The field types an authored entity may declare, in the CLI's own
+ *  vocabulary. Use for a `--type` choice list so help text and validation
+ *  cannot drift from what this module can emit. */
+export declare const AUTHORABLE_FIELD_TYPES: readonly string[];
+/** Thrown for a spec this module cannot turn into a valid field. Carries no
+ *  diagnostic code: these are caller mistakes caught before a document exists,
+ *  not document defects, which are `validateEntity`'s job. */
+export declare class AuthoredFieldError extends Error {
+    readonly instructions: string;
+    constructor(message: string, instructions: string);
+}
+/**
+ * `defaultValue` was the one field property nothing type-checked, so
+ * `{"defaultValue":{"a":1}}` went into the document verbatim — past
+ * `validateEntity`, which judges names and type pairs, and past pack, to fail
+ * at deploy where the diagnosis is hardest.
+ *
+ * The check is "is it a string the field's type can hold", not "is it a
+ * boolean for BOOLEAN": this module writes text for every type, and Data
+ * Fabric round-trips a DECIMAL default as `"0"`. Typing
+ * it as the JS value would reject the document's own content on the next
+ * update, which is exactly how the AUTO_NUMBER/`decimalPrecision` rule went
+ * wrong.
+ */
+/** How `authorField` was reached, for the few checks that depend on whether a
+ *  value is the caller's or the document's own. */
+export interface AuthorFieldOptions {
+    /** False when `defaultValue` was inherited from the existing field rather
+     *  than supplied. Its content is then not the caller's to answer for. */
+    defaultValueFromCaller?: boolean;
+}
+/**
+ * Turn a caller's field spec into an authored `EntityField`.
+ *
+ * Name rules are NOT checked here — `validateEntity` owns them, against the
+ * whole document, so a caller sees every problem at once rather than the first.
+ * Throws {@link AuthoredFieldError} only for a type this module cannot emit.
+ */
+export declare function authorField(spec: AuthoredFieldSpec, options?: AuthorFieldOptions): EntityField;

package/dist/schema/create-entity-skeleton.d.ts

@@ -1,4 +1,18 @@
 import { type EntityField, type EntityJSON } from "@uipath/entity-modeler/schema";
+/**
+ * Data Fabric resolves this on actual resource creation. Same sentinel Studio
+ * Web writes (`UNASSIGNED_FOLDER_ID` in custom-render/data-service).
+ *
+ * It is also the only reliable way to tell an entity authored locally from one
+ * imported off a tenant by `uip solution resources add`. The two resource
+ * envelopes are otherwise identical — same `kind`, `type`, `isOverridable` and
+ * `folders` — and differ only here: the sentinel for an authored entity, a real
+ * folder GUID for an imported one.
+ */
+export declare const UNASSIGNED_FOLDER_ID = "99999999-9999-9999-9999-999999999999";
+/** Was this entity authored locally, or does the solution merely reference a
+ *  live platform entity? See {@link UNASSIGNED_FOLDER_ID}. */
+export declare function isLocallyAuthored(entity: Pick<EntityJSON, "FolderId">): boolean;
 /** The 5 canonical system fields, in Studio Web's order. Also the validator's
  *  source of truth for "unmodified system fields": every property here is
  *  compared, and properties absent here are not. */
@@ -11,3 +25,10 @@ export declare const SYSTEM_FIELD_TEMPLATES: readonly EntityField[];
  * used as-is — validity is the validator's concern, not this factory's.
  */
 export declare function createEntitySkeleton(name: string): EntityJSON;
+/**
+ * An authored document is written under the name it was authored for. The
+ * resource path derives from the entity name alone, so one authored under
+ * another name would land as the wrong entity. Both write paths — adding to a
+ * project and scaffolding one — check it before they write.
+ */
+export declare function requireAuthoredName(authored: EntityJSON | undefined, entityName: string): void;

package/dist/schema/solution-entity-names.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Entity names across a solution — the input `validateEntity` needs for its
+ * uniqueness rule, which only the host can supply.
+ *
+ * Shared because two callers need the same answer: `solution pack` validating
+ * every stub in a project, and the inline commands validating one entity a
+ * caller just edited. A second copy would let the two disagree about what
+ * counts as a sibling, and the uniqueness diagnostic would fire in pack but not
+ * in the command that was supposed to catch it first.
+ */
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+/** An entity's siblings are every name in the solution except one occurrence of
+ *  its own — names are solution-wide unique. */
+export declare function withoutOneOccurrence(names: readonly string[], name: string): string[];
+/** Every entity name in the solution, read from stub filenames one directory
+ *  deep. Duplicates are kept so cross-project collisions surface. */
+export declare function collectSolutionEntityNames(solutionDir: string, fs: IFileSystem): Promise<string[]>;
+/** The sibling list for one entity, in one call — what a caller validating a
+ *  single entity wants. */
+export declare function siblingNamesFor(solutionDir: string, entityName: string, fs: IFileSystem): Promise<string[]>;
+/** Where an entity was found, and how the filesystem spells it. */
+export interface EntityOwner {
+    /** The project's directory NAME (not its path) — what the commands take. */
+    projectName: string;
+    /**
+     * The entity name as the STUB FILE spells it, which is not necessarily how
+     * the caller spelled it: the match below is case-insensitive, but every
+     * path built from the result is not. Handing back the caller's `product`
+     * for a `Product.entity` produces a `StubFileNameMismatch` on a
+     * case-insensitive filesystem and a missing file on a case-sensitive one.
+     */
+    entityName: string;
+}
+/**
+ * Which project directory owns `entityName`, searched across the solution.
+ *
+ * Entity names are solution-wide unique — `inlineEntityAddAsync` and
+ * `entityInitAsync` both refuse a name another project holds — so this is a
+ * lookup, not a guess: it finds one project or none. That is what lets
+ * `--project-name` be optional on the verbs that address an existing entity.
+ *
+ * Empty when nothing owns the name; ambiguous only if the uniqueness guard was
+ * bypassed, in which case the caller should ask.
+ */
+export declare function findProjectsOwningEntity(solutionDir: string, entityName: string, fs: IFileSystem): Promise<EntityOwner[]>;

package/dist/schema/validate-entity.d.ts

@@ -10,6 +10,9 @@ export declare const DIAGNOSTIC_CODES: {
     readonly nameReserved: "NAME_RESERVED";
     readonly systemFieldMissing: "SYSTEM_FIELD_MISSING";
     readonly systemFieldModified: "SYSTEM_FIELD_MODIFIED";
+    readonly fieldsMalformed: "FIELDS_MALFORMED";
+    readonly tooManyMultilineMax: "TOO_MANY_MULTILINE_MAX";
+    readonly propertyTypeInvalid: "PROPERTY_TYPE_INVALID";
 };
 export type DiagnosticCode = (typeof DIAGNOSTIC_CODES)[keyof typeof DIAGNOSTIC_CODES];
 export interface EntityDiagnostic {
@@ -30,3 +33,12 @@ export interface ValidateEntityContext {
  * stopping at the first, and never throws.
  */
 export declare function validateEntity(entity: EntityJSON, ctx: ValidateEntityContext): EntityDiagnostic[];
+/**
+ * Whether a stored field is a system field — exactly as `@uipath/entity-modeler`
+ * decides it (`IsSystemField === true`, the row it locks read-only), plus the
+ * five canonical names Data Fabric adds to every entity. Strictly `true`: a
+ * hand-edited `"yes"` is truthy, and reading it as system exempted a custom
+ * field from every custom-field rule. Validation and editing share this so
+ * they cannot disagree.
+ */
+export declare function isSystemField(field: unknown): boolean;

package/dist/sort-names.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The comparator every name listing in this package sorts by.
+ *
+ * A bare `Array.prototype.sort()` compares UTF-16 code units, which is not
+ * what "alphabetical" means to the person reading an entity list or an error
+ * naming the types they may use. The locale is pinned rather than left to the
+ * runtime's default so the same solution lists in the same order on a
+ * developer's machine and on a CI runner — these strings reach command output
+ * that tests and diffs compare.
+ */
+export declare function byName(a: string, b: string): number;

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@uipath/packager-tool-datafabric",
-    "version": "1.204.0",
+    "version": "1.205.0-preview.258",
     "description": "UiPath Data Fabric entity schema, validation and packaging library",
     "type": "module",
     "exports": {
         ".": "./dist/index.js",
-        "./init": "./dist/init.js"
+        "./init": "./dist/init.js",
+        "./inline": "./dist/inline.js"
     },
     "repository": {
         "type": "git",
@@ -22,7 +23,7 @@
     "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "1.204.0"
+        "@uipath/solutionpackager-tool-core": "1.205.0"
     },
-    "gitHead": "699c58dabb59414557755a8933bcbe40aa420df3"
+    "gitHead": "8f629ee9fa89abf94f197436a60cb3b9620f8b27"
 }