@prismatic-io/components-duro-plm 0.0.0-stage → 0.0.1

package/npm-dist/index.cjs

@@ -0,0 +1,1132 @@
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+let graphql_request = require("graphql-request");
+var connections_default = [(0, _prismatic_io_spectral.connection)({
+	key: "duroApiKey",
+	display: {
+		label: "API Key",
+		description: "Authenticate requests using an API key."
+	},
+	inputs: {
+		username: {
+			label: "API Key",
+			placeholder: "Enter Duro API Key",
+			example: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0",
+			comments: "The API key for the Duro account. Generate an API key in Duro account settings under the Integrations tab.",
+			type: "password",
+			required: true
+		},
+		duroEnvironment: {
+			label: "Duro Environment",
+			placeholder: "Select Duro Environment",
+			comments: "The Duro GraphQL endpoint. Select based on data residency requirements: Main (MFG) for standard accounts, ITAR for US government compliance, or EU for European data residency.",
+			type: "string",
+			required: true,
+			model: [
+				{
+					label: "Main (MFG)",
+					value: "https://mfg.duro.app/graphql"
+				},
+				{
+					label: "ITAR",
+					value: "https://gov.duro.us/graphql"
+				},
+				{
+					label: "EU",
+					value: "https://eu.duro.app/graphql"
+				}
+			],
+			example: "https://mfg.duro.app/graphql"
+		},
+		customDuroEnvironment: {
+			label: "Custom Duro Environment",
+			type: "string",
+			required: false,
+			placeholder: "Enter custom GraphQL endpoint URL",
+			comments: "If provided, this will override the selected Duro Environment. Use for private Duro instances or custom deployments.",
+			example: "https://custom-instance.duro.app/graphql"
+		}
+	}
+})];
+//#endregion
+//#region src/constants.ts
+const GRAPHQL_EXAMPLE = `{
+  components(libraryType: GENERAL) {
+    connection(
+      first: 10
+    ) {
+      totalCount
+      edges {
+        cursor
+        node {
+          id
+          name
+          created
+          lastModified
+        }
+      }
+    }
+  }
+}`;
+const LOOK_BACK_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const POLL_RESOURCE_CONFIG = {
+	components: {
+		query: `
+      query PollComponents($first: Int, $after: String, $libraryType: LibraryType, $orderBy: [ComponentsOrderByInput]) {
+        components(libraryType: $libraryType, orderBy: $orderBy) {
+          connection(first: $first, after: $after) {
+            edges {
+              cursor
+              node {
+                id
+                name
+                created
+                lastModified
+              }
+            }
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+          }
+        }
+      }
+    `,
+		dataPath: ["components", "connection"],
+		buildVariables: (first, after) => ({
+			first,
+			after,
+			libraryType: "GENERAL",
+			orderBy: [{ lastModified: "desc" }]
+		}),
+		earlyStop: true
+	},
+	changeOrders: {
+		query: `
+      query PollChangeOrders($first: Int, $after: String, $orderBy: [ChangeOrdersOrderByInput]) {
+        changeOrders(orderBy: $orderBy) {
+          connection(first: $first, after: $after) {
+            edges {
+              cursor
+              node {
+                id
+                name
+                status
+                type
+                created
+                lastModified
+              }
+            }
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+          }
+        }
+      }
+    `,
+		dataPath: ["changeOrders", "connection"],
+		buildVariables: (first, after) => ({
+			first,
+			after,
+			orderBy: [{ lastModified: "desc" }]
+		}),
+		earlyStop: true
+	}
+};
+//#endregion
+//#region src/util/index.ts
+const validateConnection = (connection) => {
+	if (!connections_default.map((c) => c.key).includes(connection.key)) throw new _prismatic_io_spectral.ConnectionError(connection, `Unsupported connection ${connection.key}.`);
+};
+const cleanStringInput = (value) => value ? _prismatic_io_spectral.util.types.toString(value) : void 0;
+const cleanNumberInput = (value) => value ? _prismatic_io_spectral.util.types.toNumber(value) : void 0;
+const getCredentials = (connection) => {
+	const url = _prismatic_io_spectral.util.types.toString(connection.fields.customDuroEnvironment).trim() || _prismatic_io_spectral.util.types.toString(connection.fields.duroEnvironment);
+	return {
+		apiKey: _prismatic_io_spectral.util.types.toString(connection.fields.username),
+		url
+	};
+};
+const cleanCodeInput = (value) => value ? _prismatic_io_spectral.util.types.toObject(value) : {};
+const cleanKeyValueListInput = (value) => {
+	if (Array.isArray(value)) return _prismatic_io_spectral.util.types.keyValPairListToObject(value);
+	return {};
+};
+const parseJsonArray = (value) => {
+	if (value) {
+		const json = _prismatic_io_spectral.util.types.toObject(value);
+		if (!Array.isArray(json)) throw new Error("Expected a JSON array");
+		return json;
+	}
+	return [];
+};
+const mapComponentEdges = (edges) => edges.map((edge) => edge.node);
+const getComponentsList = async (client, query, first, libraryType) => {
+	const variables = {
+		first,
+		libraryType
+	};
+	const edges = (await client.request(query, variables))?.components?.connection?.edges ?? [];
+	return mapComponentEdges(edges);
+};
+const toResourceLabel = (key) => key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (char) => char.toUpperCase());
+const pollResourceModel = Object.entries(POLL_RESOURCE_CONFIG).map(([value]) => ({
+	label: toResourceLabel(value),
+	value
+}));
+const readConnection = (data, dataPath) => {
+	let current = data;
+	for (const key of dataPath) if (current && typeof current === "object") current = current[key];
+	else return;
+	return current;
+};
+const fetchAllSince = async (client, resourceType, lastPolledAt, options = {}) => {
+	const config = POLL_RESOURCE_CONFIG[resourceType];
+	if (!config) throw new Error(`Unsupported resource type: ${resourceType}`);
+	const { debug, logger } = options;
+	const lastPolledAtDate = new Date(lastPolledAt);
+	const records = [];
+	let after = options.after;
+	let page = 0;
+	while (page < 50) {
+		page += 1;
+		const variables = config.buildVariables(100, after);
+		const data = await client.request(config.query, variables);
+		const connection = readConnection(data, config.dataPath);
+		const edges = connection?.edges ?? [];
+		let stop = false;
+		for (const edge of edges) {
+			const node = edge?.node;
+			if (!node) continue;
+			records.push(node);
+			if (config.earlyStop && typeof node.lastModified === "string" && new Date(node.lastModified) <= lastPolledAtDate) {
+				stop = true;
+				break;
+			}
+		}
+		if (stop) return {
+			records,
+			truncated: false
+		};
+		const pageInfo = connection?.pageInfo;
+		if (!pageInfo?.hasNextPage || !pageInfo.endCursor) return {
+			records,
+			truncated: false
+		};
+		after = pageInfo.endCursor;
+	}
+	if (debug && logger) logger.warn(`Reached MAX_POLL_PAGES (50) while polling ${resourceType}; results truncated. The next poll resumes from the held cursor.`);
+	return {
+		records,
+		truncated: true,
+		endCursor: after
+	};
+};
+const resolvePollingStart = (state, lookBackDate, now) => ({
+	since: state?.lastPolledAt ?? (lookBackDate || now),
+	isBackfill: state?.backfillActive === true || !state?.lastPolledAt && Boolean(lookBackDate)
+});
+const resolvePollingStream = (state, resourceType, now) => {
+	return Boolean(state?.endCursor) && Boolean(state?.streamStartedAt) && state?.pollResourceType === resourceType ? {
+		streamStartedAt: state?.streamStartedAt,
+		endCursor: state?.endCursor
+	} : { streamStartedAt: now };
+};
+const nextPollingState = (round, endCursor) => endCursor ? {
+	lastPolledAt: round.lastPolledAt,
+	endCursor,
+	streamStartedAt: round.stream.streamStartedAt,
+	pollResourceType: round.resourceType,
+	...round.isBackfill ? { backfillActive: true } : {}
+} : { lastPolledAt: round.stream.streamStartedAt };
+const lookBackDateClean = (value) => {
+	if (value === void 0 || value === null || typeof value === "string" && value.trim() === "") return "";
+	const raw = typeof value === "string" ? value.trim() : String(value);
+	const match = typeof value === "string" ? raw.match(LOOK_BACK_DATE_PATTERN) : null;
+	if (!match) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	const [, yearStr, monthStr, dayStr] = match;
+	const year = Number(yearStr);
+	const month = Number(monthStr);
+	const day = Number(dayStr);
+	const parsed = new Date(Date.UTC(year, month - 1, day));
+	if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	if (parsed.getTime() > Date.now()) throw new Error(`Look-back Date cannot be a future date. Received: ${raw}`);
+	return parsed.toISOString();
+};
+const classifyRecords = (records, lastPolledAt, options) => {
+	const lastPolledAtDate = new Date(lastPolledAt);
+	const created = [];
+	const updated = [];
+	for (const record of records) {
+		const createdDate = typeof record.created === "string" ? new Date(record.created) : null;
+		const lastModifiedDate = typeof record.lastModified === "string" ? new Date(record.lastModified) : null;
+		const isNew = createdDate !== null && createdDate > lastPolledAtDate;
+		const isUpdated = !isNew && lastModifiedDate !== null && lastModifiedDate > lastPolledAtDate;
+		if (isNew && (options.isBackfill || options.showNewRecords)) created.push(record);
+		else if (isUpdated && (options.isBackfill || options.showUpdatedRecords)) updated.push(record);
+	}
+	return {
+		created,
+		updated
+	};
+};
+const resolveRecordChanges = (data) => {
+	const changesObject = data ?? {};
+	return [...(changesObject.created ?? []).map((record) => ({
+		changeType: "created",
+		record
+	})), ...(changesObject.updated ?? []).map((record) => ({
+		changeType: "updated",
+		record
+	}))];
+};
+//#endregion
+//#region src/client.ts
+const createDuroClient = (connection, debug) => {
+	validateConnection(connection);
+	const { apiKey, url } = getCredentials(connection);
+	return new graphql_request.GraphQLClient(url, {
+		headers: { apiToken: apiKey },
+		requestMiddleware: (request) => {
+			if (debug) console.log(JSON.stringify(request));
+			return request;
+		},
+		responseMiddleware: (response) => {
+			if (debug) console.log(JSON.stringify(response));
+			return response;
+		}
+	});
+};
+//#endregion
+//#region src/inputs/common.ts
+const connection = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true,
+	comments: "The Duro PLM connection to use."
+});
+const first = (0, _prismatic_io_spectral.input)({
+	label: "First N Items",
+	comments: "The number of items to return.",
+	example: "10",
+	placeholder: "Enter number of items",
+	type: "string",
+	required: false,
+	clean: cleanNumberInput
+});
+//#endregion
+//#region src/inputs/company.ts
+const listCompanyUsersInputs = { connection };
+//#endregion
+//#region src/examplePayloads.ts
+const getCurrentUserExamplePayload = { data: { userById: {
+	lastName: "Smith",
+	email: "john.smith@example.com",
+	firstName: "John",
+	id: "1234567890abcdef12345678",
+	primaryCompany: {
+		id: "abcdef1234567890abcdef12",
+		name: "ExampleCorp"
+	}
+} } };
+const listCompanyUsersExamplePayload = { data: {
+	id: "abcdef1234567890abcdef12",
+	name: "ExampleCorp",
+	users: [{
+		email: "john.doe@example.com",
+		id: "1234567890abcdef12345678",
+		firstName: "John",
+		lastName: "Doe",
+		created: "2024-06-14T14:57:37.227Z",
+		role: "ADMINISTRATOR",
+		title: "CEO",
+		lastLogin: "2024-06-24T16:11:02.889Z"
+	}]
+} };
+const getComponentByIdExamplePayload = { data: { componentsByIds: [{
+	id: "abcdef1234567890abcdef12",
+	cpn: { displayValue: "123-45678" },
+	created: "2024-06-14T14:58:29.791Z",
+	category: "Integrated Circuit",
+	archived: false,
+	customSpecs: [],
+	description: "A high-performance integrated circuit for advanced applications.",
+	documentLinks: [],
+	eid: "20-4567-B2",
+	family: "IC",
+	images: [{
+		mime: "JPEG",
+		creator: { email: "john.doe@example.com" },
+		name: "ic_image.jpg",
+		src: "https://example.com/ic_image.jpg"
+	}],
+	legacyCpn: "123-45678",
+	lastModified: "2024-06-14T14:58:30.229Z",
+	manufacturers: [],
+	name: "High-Performance IC",
+	primarySource: {
+		dpn: "DP1234",
+		distributor: "Distributor Inc.",
+		manufacturer: "IC Manufacturer Ltd.",
+		minQuantity: 10,
+		mpn: "MP1234",
+		unitPrice: 5.99
+	},
+	specs: [],
+	status: "PRODUCTION",
+	revisionValue: "1",
+	workflowState: "Approved",
+	vendorId: "V1234",
+	creator: {
+		id: "1234567890abcdef12345678",
+		email: "john.doe@example.com",
+		firstName: "John",
+		lastName: "Doe"
+	},
+	revisionHistory: [{
+		id: "abcdef1234567890abcdef34",
+		cpn: { displayValue: "123-45678" },
+		revisionValue: "1"
+	}],
+	children: [{ component: { id: "abcdef1234567890abcdef56" } }, { component: { id: "abcdef1234567890abcdef78" } }],
+	modified: false,
+	imageIds: ["abcdef1234567890abcdef90"]
+}] } };
+const createChangeOrderExamplePayload = { data: { createChangeOrder: {
+	id: "abcdef1234567890abcdef12",
+	con: { displayValue: "ECO-12345" },
+	description: "Initial creation of the change order for testing purposes.",
+	name: "Initial Change Order",
+	status: "DRAFT",
+	type: "ECO",
+	created: "2024-06-24T22:31:27.808Z",
+	creator: {
+		email: "john.doe@example.com",
+		id: "1234567890abcdef12345678",
+		firstName: "John",
+		lastName: "Doe"
+	}
+} } };
+const listChangeOrdersExamplePayload = { data: { changeOrders: { connection: { edges: [{ node: {
+	con: {
+		id: "abcdef1234567890abcdef12",
+		displayValue: "ECO-12345"
+	},
+	id: "abcdef1234567890abcdef34",
+	name: "PCB Revision for Rev B Release",
+	type: "ECO",
+	description: "Engineering change order to update PCB layout for Rev B manufacturing release.",
+	documentLinks: [],
+	status: "DRAFT",
+	resolution: "NONE",
+	erpOptions: null,
+	created: "2024-06-24T22:31:27.808Z",
+	creator: {
+		email: "john.doe@example.com",
+		id: "1234567890abcdef12345678",
+		firstName: "John",
+		lastName: "Doe"
+	},
+	approvalType: "FIRST_IN",
+	lastModified: "2024-06-24T22:31:27.808Z"
+} }] } } } };
+const listComponentsExamplePayload = { data: [{
+	id: "666c5a8828e82100081595b0",
+	name: "CONN HEADER 10POS DUAL .05\", Keying Shroud, SMD",
+	mass: null,
+	created: "2024-06-14T14:58:16.638Z",
+	lastModified: "2024-06-14T14:58:18.069Z"
+}] };
+const rawRequestExamplePayload = { data: { componentsByIds: [{
+	id: "abcdef1234567890abcdef12",
+	name: "High-Performance IC"
+}] } };
+const pollChangesExamplePayload = {
+	payload: {
+		headers: {},
+		queryParameters: {},
+		rawBody: {
+			data: "",
+			contentType: "application/json"
+		},
+		body: { data: {
+			created: [{
+				id: "666c5a8828e82100081595b0",
+				name: "High-Performance IC",
+				created: "2024-06-14T14:58:16.638Z",
+				lastModified: "2024-06-14T14:58:16.638Z"
+			}],
+			updated: [{
+				id: "666c5a9528e821000815990e",
+				name: "Precision Resistor 10k",
+				created: "2024-06-10T09:12:04.118Z",
+				lastModified: "2024-06-14T14:58:18.069Z"
+			}]
+		} },
+		pathFragment: "",
+		webhookUrls: { "Polling Flow": "https://hooks.example.com/trigger/EXAMPLE" },
+		webhookApiKeys: { "Polling Flow": ["example-api-key"] },
+		invokeUrl: "https://hooks.example.com/trigger/EXAMPLE",
+		executionId: "SW5zdGFuY2VFeGVjdXRpb246MTIzNDU=",
+		customer: {
+			id: "Q3VzdG9tZXI6MTIzNDU=",
+			externalId: "example-customer-external-id",
+			name: "Example Customer"
+		},
+		instance: {
+			id: "SW5zdGFuY2U6MTIzNDU=",
+			name: "Example Instance"
+		},
+		user: {
+			id: "VXNlcjoxMjM0NQ==",
+			externalId: "example-user-external-id",
+			name: "Example User",
+			email: "user@example.com"
+		}
+	},
+	polledNoChanges: false
+};
+//#endregion
+//#region src/actions/company/index.ts
+var company_default = { listCompanyUsers: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Company Users",
+		description: "Retrieves account information for each user in the company library."
+	},
+	inputs: listCompanyUsersInputs,
+	perform: async (context, { connection }) => {
+		const client = createDuroClient(connection, context.debug.enabled);
+		const query = graphql_request.gql`
+      query UserById {
+        userById {
+          primaryCompany {
+            id
+            name
+            users {
+              email
+              id
+              firstName
+              lastName
+              created
+              role
+              title
+              lastLogin
+            }
+          }
+        }
+      }
+    `;
+		return { data: (await client.request(query)).userById.primaryCompany };
+	},
+	examplePayload: listCompanyUsersExamplePayload
+}) };
+//#endregion
+//#region src/inputs/components.ts
+const libraryType = (0, _prismatic_io_spectral.input)({
+	label: "Library Type",
+	comments: "The type of library to query. Company (GENERAL) contains shared production components, while Sandbox (PERSONAL) contains personal or test components.",
+	example: "GENERAL",
+	placeholder: "Select Library Type",
+	type: "string",
+	required: true,
+	clean: cleanStringInput,
+	model: [{
+		label: "Company",
+		value: "GENERAL"
+	}, {
+		label: "Sandbox",
+		value: "PERSONAL"
+	}]
+});
+const componentId = (0, _prismatic_io_spectral.input)({
+	label: "Component ID",
+	comments: "The unique identifier for the component to retrieve.",
+	type: "string",
+	required: true,
+	example: "666c5a9528e821000815990e",
+	placeholder: "Enter Component ID",
+	clean: cleanStringInput,
+	dataSource: "selectComponent"
+});
+const listComponentsInputs = {
+	connection,
+	libraryType,
+	first
+};
+const getComponentByIdInputs = {
+	connection,
+	componentId
+};
+//#endregion
+//#region src/actions/components/index.ts
+var components_default$1 = {
+	getComponentById: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Component by ID",
+			description: "Get a specific component by a unique identifier"
+		},
+		inputs: getComponentByIdInputs,
+		perform: async (context, { connection, componentId }) => {
+			const client = createDuroClient(connection, context.debug.enabled);
+			const query = graphql_request.gql`
+      query ComponentsByIds($ids: [ID]) {
+        componentsByIds(ids: $ids) {
+          id
+          cpn {
+            displayValue
+          }
+          created
+          category
+          archived
+          customSpecs {
+            key
+            specId
+            value
+          }
+          description
+          documentLinks {
+            document {
+              src
+              name
+              mime
+              id
+              archived
+              url
+            }
+            specs {
+              status
+              type
+              revision
+              lastModified
+            }
+          }
+          eid
+          family
+          images {
+            mime
+            creator {
+              email
+            }
+            name
+            src
+          }
+          legacyCpn
+          lastModified
+          manufacturers {
+            name
+            description
+            mpn {
+              key
+              src
+            }
+          }
+          name
+          primarySource {
+            dpn
+            distributor
+            manufacturer
+            minQuantity
+            mpn
+            unitPrice
+          }
+          specs {
+            key
+            value
+          }
+          status
+          revisionValue
+          workflowState
+          vendorId
+          creator {
+            id
+            email
+            firstName
+            lastName
+          }
+          revisionHistory {
+            id
+            cpn {
+              displayValue
+            }
+            revisionValue
+          }
+          children {
+            component {
+              id
+            }
+          }
+          modified
+          imageIds
+        }
+      }
+    `;
+			const variables = { ids: [componentId] };
+			return { data: await client.request(query, variables) };
+		},
+		examplePayload: getComponentByIdExamplePayload
+	}),
+	listComponents: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Components",
+			description: "Retrieves a list of components."
+		},
+		inputs: listComponentsInputs,
+		perform: async (context, { connection, libraryType, first }) => {
+			return { data: await getComponentsList(createDuroClient(connection, context.debug.enabled), graphql_request.gql`
+      query Components($first: Int, $libraryType: LibraryType) {
+        components(libraryType: $libraryType) {
+          connection(first: $first) {
+            edges {
+              node {
+                id
+                name
+                mass
+                created
+                lastModified
+              }
+            }
+          }
+        }
+      }
+    `, first ?? 100, libraryType ?? "GENERAL") };
+		},
+		examplePayload: listComponentsExamplePayload
+	})
+};
+const rawRequestInputs = {
+	connection,
+	query: (0, _prismatic_io_spectral.input)({
+		label: "Query or Mutation",
+		type: "code",
+		required: true,
+		language: "graphql",
+		comments: "GraphQL query or mutation to execute against the Duro API. See the Duro GraphQL API documentation for available queries and mutations.",
+		placeholder: "Enter GraphQL query or mutation",
+		default: GRAPHQL_EXAMPLE,
+		example: GRAPHQL_EXAMPLE,
+		clean: cleanStringInput
+	}),
+	variables: (0, _prismatic_io_spectral.input)({
+		label: "Variables",
+		type: "string",
+		required: false,
+		collection: "keyvaluelist",
+		comments: "GraphQL variables to pass to the query or mutation. Each variable should be a key-value pair.",
+		example: "{\"userId\": \"12345\", \"status\": \"active\"}",
+		placeholder: "Enter key-value pairs",
+		clean: cleanKeyValueListInput
+	}),
+	variablesObject: (0, _prismatic_io_spectral.input)({
+		label: "Variables Object",
+		type: "code",
+		comments: "Alternative way to provide GraphQL variables as a JSON object. Use this instead of the Variables field for complex nested variables.",
+		placeholder: "Enter GraphQL variables as JSON",
+		example: JSON.stringify({
+			key1: "value1",
+			key2: "value2"
+		}, null, 2),
+		language: "json",
+		required: false,
+		clean: cleanCodeInput
+	})
+};
+//#endregion
+//#region src/actions/misc/index.ts
+var misc_default = { rawRequest: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Make a generic request to the Duro API"
+	},
+	inputs: rawRequestInputs,
+	perform: async (context, { connection, query, variables, variablesObject }) => {
+		return { data: await createDuroClient(connection, context.debug.enabled).request(query ?? "", {
+			...variables,
+			...variablesObject
+		}) };
+	},
+	examplePayload: rawRequestExamplePayload
+}) };
+//#endregion
+//#region src/inputs/orders.ts
+const name = (0, _prismatic_io_spectral.input)({
+	label: "Name",
+	type: "string",
+	comments: "The name of the change order to create.",
+	example: "ECO-2024-001: Update Component Materials",
+	placeholder: "Enter change order name",
+	required: true,
+	clean: cleanStringInput
+});
+const description = (0, _prismatic_io_spectral.input)({
+	label: "Description",
+	type: "text",
+	required: false,
+	comments: "A detailed description of the change order, including the reason for the change and expected impact.",
+	example: "Replace aluminum housing with stainless steel to improve corrosion resistance in marine environments.",
+	placeholder: "Enter change order description",
+	clean: cleanStringInput
+});
+const type = (0, _prismatic_io_spectral.input)({
+	label: "Type",
+	type: "string",
+	required: true,
+	comments: "The type of change order to create. ECO (Engineering Change Order), MCO (Manufacturing Change Order), or DCO (Document Change Order).",
+	clean: cleanStringInput,
+	default: "ECO",
+	placeholder: "Select change order type",
+	model: [
+		{
+			label: "ECO (Engineering Change Order)",
+			value: "ECO"
+		},
+		{
+			label: "MCO (Manufacturing Change Order)",
+			value: "MCO"
+		},
+		{
+			label: "DCO (Document Change Order)",
+			value: "DCO"
+		}
+	],
+	example: "ECO"
+});
+const orderBy = (0, _prismatic_io_spectral.input)({
+	label: "Order By",
+	comments: "The field and direction to sort the change orders by. Results will be returned in the specified order.",
+	example: "[{\"con\": \"asc\"}]",
+	placeholder: "Select sort order",
+	type: "string",
+	required: false,
+	clean: parseJsonArray,
+	model: [
+		{
+			label: "ID: Ascending",
+			value: "[{\"con\": \"asc\"}]"
+		},
+		{
+			label: "ID: Descending",
+			value: "[{\"con\": \"desc\"}]"
+		},
+		{
+			label: "Last Modified: Ascending",
+			value: "[{\"lastModified\": \"asc\"}]"
+		},
+		{
+			label: "Last Modified: Descending",
+			value: "[{\"lastModified\": \"desc\"}]"
+		},
+		{
+			label: "Name: Ascending",
+			value: "[{\"name\": \"asc\"}]"
+		},
+		{
+			label: "Name: Descending",
+			value: "[{\"name\": \"desc\"}]"
+		}
+	]
+});
+const createChangeOrderInputs = {
+	connection,
+	name,
+	description,
+	type
+};
+const listChangeOrdersInputs = {
+	connection,
+	orderBy,
+	first
+};
+//#endregion
+//#region src/actions/orders/createChangeOrder.ts
+const createChangeOrder = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Change Order",
+		description: "Creates a draft change order."
+	},
+	inputs: createChangeOrderInputs,
+	perform: async (context, { connection, name, description, type }) => {
+		const client = createDuroClient(connection, context.debug.enabled);
+		const query = graphql_request.gql`
+      mutation CreateChangeOrder($input: CreateChangeOrderInput) {
+        createChangeOrder(input: $input) {
+          id
+          con {
+            displayValue
+          }
+          description
+          name
+          status
+          type
+          created
+          creator {
+            email
+            id
+            firstName
+            lastName
+          }
+        }
+      }
+    `;
+		const variables = { input: {
+			name,
+			description,
+			type
+		} };
+		return { data: await client.request(query, variables) };
+	},
+	examplePayload: createChangeOrderExamplePayload
+});
+//#endregion
+//#region src/actions/orders/index.ts
+var orders_default = {
+	listChangeOrders: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Change Orders",
+			description: "Retrieves a list of change orders."
+		},
+		inputs: listChangeOrdersInputs,
+		perform: async (context, { connection, orderBy, first }) => {
+			const client = createDuroClient(connection, context.debug.enabled);
+			const query = graphql_request.gql`
+      query ChangeOrders($first: Int, $orderBy: [ChangeOrdersOrderByInput]) {
+        changeOrders(orderBy: $orderBy) {
+          connection(first: $first) {
+            edges {
+              node {
+                con {
+                  id
+                  displayValue
+                }
+                id
+                name
+                type
+                description
+                documentLinks {
+                  document {
+                    id
+                    size
+                    src
+                    name
+                    url
+                    status
+                    created
+                  }
+                }
+                status
+                resolution
+                erpOptions {
+                  effectivity {
+                    endDate
+                    startDate
+                  }
+                  itemType {
+                    value
+                  }
+                }
+                created
+                creator {
+                  email
+                  id
+                  firstName
+                  lastName
+                }
+                approvalType
+                lastModified
+              }
+            }
+          }
+        }
+      }
+    `;
+			const variables = {
+				first: first ?? 100,
+				orderBy
+			};
+			return { data: await client.request(query, variables) };
+		},
+		examplePayload: listChangeOrdersExamplePayload
+	}),
+	createChangeOrder
+};
+//#endregion
+//#region src/inputs/users.ts
+const getCurrentUserInputs = { connection };
+//#endregion
+//#region src/actions/users/index.ts
+var users_default = { getCurrentUser: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Current User",
+		description: "Get information about the currently authenticated user"
+	},
+	inputs: getCurrentUserInputs,
+	perform: async (context, { connection }) => {
+		const client = createDuroClient(connection, context.debug.enabled);
+		const query = graphql_request.gql`
+      query UserById {
+        userById {
+          lastName
+          email
+          firstName
+          id
+          primaryCompany {
+            id
+            name
+          }
+        }
+      }
+    `;
+		return { data: await client.request(query) };
+	},
+	examplePayload: getCurrentUserExamplePayload
+}) };
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...company_default,
+	...components_default$1,
+	...misc_default,
+	...orders_default,
+	...users_default
+};
+//#endregion
+//#region src/inputs/dataSources.ts
+const selectComponentInputs = listComponentsInputs;
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = { selectComponent: (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "Select Component",
+		description: "A picklist of components in your library."
+	},
+	inputs: selectComponentInputs,
+	dataSourceType: "picklist",
+	perform: async (_context, { connection, libraryType, first }) => {
+		return { result: (await getComponentsList(createDuroClient(connection, false), graphql_request.gql`
+      query Components($first: Int, $libraryType: LibraryType) {
+        components(libraryType: $libraryType) {
+          connection(first: $first) {
+            edges {
+              node {
+                id
+                name
+              }
+            }
+          }
+        }
+      }
+    `, first ?? 100, libraryType ?? "GENERAL")).map((component) => ({
+			key: component.id,
+			label: component.name
+		})) };
+	}
+}) };
+const pollChangesInputs = {
+	connection,
+	pollResourceType: (0, _prismatic_io_spectral.input)({
+		label: "Resource Type",
+		type: "string",
+		required: true,
+		model: pollResourceModel,
+		comments: "The type of resource to poll for changes.",
+		example: "components",
+		placeholder: "Select resource type",
+		clean: _prismatic_io_spectral.util.types.toString
+	}),
+	lookBackDate: (0, _prismatic_io_spectral.input)({
+		label: "Look-back Date",
+		placeholder: "Enter look-back date (YYYY-MM-DD)",
+		type: "string",
+		required: false,
+		comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each record modified on or after this date once, ignoring the visibility filters.",
+		example: "2026-01-01",
+		clean: lookBackDateClean
+	}),
+	showNewRecords: (0, _prismatic_io_spectral.input)({
+		label: "Show New Records",
+		type: "boolean",
+		required: false,
+		default: "true",
+		comments: "When true, newly created records are included in the trigger output.",
+		clean: _prismatic_io_spectral.util.types.toBool
+	}),
+	showUpdatedRecords: (0, _prismatic_io_spectral.input)({
+		label: "Show Updated Records",
+		type: "boolean",
+		required: false,
+		default: "true",
+		comments: "When true, records updated after the last poll are included in the trigger output.",
+		clean: _prismatic_io_spectral.util.types.toBool
+	})
+};
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = { pollChangesTrigger: (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New and Updated Records",
+		description: "Retrieves existing and ongoing components or change orders in Duro. Load history once, check for changes on a schedule, or both."
+	},
+	inputs: pollChangesInputs,
+	examplePayload: pollChangesExamplePayload,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: { resolveItems: (_context, { payload }) => resolveRecordChanges(payload.body.data) },
+	perform: async (context, payload, params) => {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const pollState = context.polling.getState();
+		const { since: lastPolledAt, isBackfill } = resolvePollingStart(pollState, params.lookBackDate, now);
+		const stream = resolvePollingStream(pollState, params.pollResourceType, now);
+		if (!POLL_RESOURCE_CONFIG[params.pollResourceType]) throw new Error(`Unsupported resource type: ${params.pollResourceType}`);
+		const { records, truncated, endCursor } = await fetchAllSince(createDuroClient(params.connection, context.debug.enabled), params.pollResourceType, lastPolledAt, {
+			after: stream.endCursor,
+			debug: context.debug.enabled,
+			logger: context.logger
+		});
+		const { created, updated } = classifyRecords(records, lastPolledAt, {
+			...params,
+			isBackfill
+		});
+		const totalMatched = created.length + updated.length;
+		context.polling.setState(nextPollingState({
+			lastPolledAt,
+			stream,
+			resourceType: params.pollResourceType,
+			isBackfill
+		}, truncated ? endCursor : void 0));
+		if (truncated) context.logger.warn(`Polling truncated at the page cap for ${params.pollResourceType}. Holding cursor at ${lastPolledAt}; the next poll resumes from the stored cursor.`);
+		if (context.debug.enabled) context.logger.debug(`Polled ${params.pollResourceType}: ${records.length} fetched, ${created.length} created, ${updated.length} updated, truncated=${truncated}`);
+		return {
+			payload: {
+				...payload,
+				body: { data: {
+					created,
+					updated
+				} }
+			},
+			polledNoChanges: totalMatched === 0
+		};
+	}
+}) };
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "duro-plm",
+	public: true,
+	documentationUrl: "https://prismatic.io/docs/components/duro-plm/",
+	display: {
+		label: "Duro PLM",
+		description: "Manage products, components, and change orders in Duro PLM.",
+		iconPath: "icon.png",
+		category: "Application Connectors"
+	},
+	hooks: { error: _prismatic_io_spectral_http.handleErrors },
+	actions: actions_default,
+	triggers: triggers_default,
+	connections: connections_default,
+	dataSources: dataSources_default
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;