@ronin/compiler 0.2.1 → 0.2.2

package/README.md

@@ -49,7 +49,6 @@ const query = {
 
 const schemas = [
   {
-    pluralSlug: 'accounts',
     slug: 'account',
   },
 ];

package/dist/index.d.ts

@@ -4667,7 +4667,7 @@ type SchemaFieldNormal = SchemaFieldBasics & {
 type SchemaFieldReferenceAction = 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT' | 'NO ACTION';
 type SchemaFieldReference = SchemaFieldBasics & {
     type: 'reference';
-    target: Omit<Partial<Schema>, 'pluralSlug'> & Pick<Schema, 'pluralSlug'>;
+    target: Omit<Partial<Schema>, 'slug'> & Pick<Schema, 'slug'>;
     kind?: 'one' | 'many';
     actions?: {
         onDelete?: SchemaFieldReferenceAction;
@@ -4679,7 +4679,7 @@ interface Schema {
     name?: string;
     pluralName?: string;
     slug: string;
-    pluralSlug: string;
+    pluralSlug?: string;
     identifiers?: {
         title?: string;
         slug?: string;

package/dist/index.js

@@ -82,6 +82,7 @@ var splitQuery = (query) => {
 };
 
 // src/utils/schema.ts
+import title from "title";
 var getSchemaBySlug = (schemas, slug) => {
   const schema = schemas.find((schema2) => {
     return schema2.slug === slug || schema2.pluralSlug === slug;
@@ -97,9 +98,6 @@ var getSchemaBySlug = (schemas, slug) => {
 var getTableForSchema = (schema) => {
   return convertToSnakeCase(schema.pluralSlug);
 };
-var getSchemaName = (schema) => {
-  return schema.name || schema.slug;
-};
 var composeMetaSchemaSlug = (suffix) => convertToCamelCase(`ronin_${suffix}`);
 var composeAssociationSchemaSlug = (schema, field) => composeMetaSchemaSlug(`${schema.pluralSlug}_${field.slug}`);
 var getFieldSelector = (field, fieldPath, rootTable) => {
@@ -126,7 +124,7 @@ var getFieldFromSchema = (schema, fieldPath, instructionName, rootTable) => {
   schemaField = schemaFields.find((field) => field.slug === fieldPath);
   if (!schemaField) {
     throw new RoninError({
-      message: `${errorPrefix} does not exist in schema "${getSchemaName(schema)}".`,
+      message: `${errorPrefix} does not exist in schema "${schema.name}".`,
       code: "FIELD_NOT_FOUND",
       field: fieldPath,
       queries: null
@@ -201,27 +199,62 @@ var SYSTEM_SCHEMAS = [
       { slug: "name", type: "string" },
       { slug: "slug", type: "string", required: true },
       { slug: "type", type: "string", required: true },
-      { slug: "schema", type: "reference", target: { pluralSlug: "schemas" } },
+      {
+        slug: "schema",
+        type: "reference",
+        target: { slug: "schema" },
+        required: true
+      },
       { slug: "required", type: "boolean" },
       { slug: "defaultValue", type: "string" },
       { slug: "unique", type: "boolean" },
       { slug: "autoIncrement", type: "boolean" },
       // Only allowed for fields of type "reference".
-      { slug: "target", type: "reference", target: { pluralSlug: "schemas" } },
+      { slug: "target", type: "reference", target: { slug: "schema" } },
       { slug: "kind", type: "string" },
       { slug: "actions", type: "group" },
       { slug: "actions.onDelete", type: "string" },
       { slug: "actions.onUpdate", type: "string" }
     ]
+  },
+  {
+    name: "Index",
+    pluralName: "Indexes",
+    slug: "index",
+    pluralSlug: "indexes",
+    fields: [
+      ...SYSTEM_FIELDS,
+      { slug: "slug", type: "string", required: true },
+      {
+        slug: "schema",
+        type: "reference",
+        target: { slug: "schema" },
+        required: true
+      },
+      { slug: "unique", type: "boolean" },
+      { slug: "filter", type: "json" }
+    ]
   }
 ];
+var SYSTEM_SCHEMA_SLUGS = SYSTEM_SCHEMAS.flatMap(({ slug, pluralSlug }) => [
+  slug,
+  pluralSlug
+]);
+var prepareSchema = (schema) => {
+  const copiedSchema = { ...schema };
+  if (!copiedSchema.pluralSlug) copiedSchema.pluralSlug = pluralize(copiedSchema.slug);
+  if (!copiedSchema.name) copiedSchema.name = slugToName(copiedSchema.slug);
+  if (!copiedSchema.pluralName)
+    copiedSchema.pluralName = slugToName(copiedSchema.pluralSlug);
+  return copiedSchema;
+};
 var addSystemSchemas = (schemas) => {
-  const list = [...SYSTEM_SCHEMAS, ...schemas].map((schema) => ({ ...schema }));
+  const list = [...SYSTEM_SCHEMAS, ...schemas].map(prepareSchema);
   for (const schema of list) {
     const defaultIncluding = {};
     for (const field of schema.fields || []) {
       if (field.type === "reference" && !field.slug.startsWith("ronin.")) {
-        const relatedSchema = getSchemaBySlug(list, field.target.pluralSlug);
+        const relatedSchema = getSchemaBySlug(list, field.target.slug);
         let fieldSlug = relatedSchema.slug;
         if (field.kind === "many") {
           fieldSlug = composeAssociationSchemaSlug(schema, field);
@@ -253,7 +286,7 @@ var addSystemSchemas = (schemas) => {
             }
           }
         };
-        const relatedSchemaToModify = getSchemaBySlug(list, field.target.pluralSlug);
+        const relatedSchemaToModify = getSchemaBySlug(list, field.target.slug);
         if (!relatedSchemaToModify) throw new Error("Missing related schema");
         relatedSchemaToModify.including = {
           [schema.pluralSlug]: {
@@ -298,7 +331,7 @@ var getFieldStatement = (field) => {
     statement += ` DEFAULT ${field.defaultValue}`;
   if (field.type === "reference") {
     const actions = field.actions || {};
-    const targetTable = convertToSnakeCase(field.target.pluralSlug);
+    const targetTable = convertToSnakeCase(pluralize(field.target.slug));
     statement += ` REFERENCES ${targetTable}("id")`;
     for (const trigger in actions) {
       const triggerName = trigger.toUpperCase().slice(2);
@@ -311,65 +344,72 @@ var getFieldStatement = (field) => {
 var addSchemaQueries = (queryDetails, writeStatements) => {
   const { queryType, querySchema, queryInstructions } = queryDetails;
   if (!["create", "set", "drop"].includes(queryType)) return;
-  if (!["schema", "schemas", "field", "fields"].includes(querySchema)) return;
+  if (!SYSTEM_SCHEMA_SLUGS.includes(querySchema)) return;
   const instructionName = mappedInstructions[queryType];
   const instructionList = queryInstructions[instructionName];
-  const kind = ["schema", "schemas"].includes(querySchema) ? "schemas" : "fields";
-  const instructionTarget = kind === "schemas" ? instructionList : instructionList?.schema;
+  const kind = getSchemaBySlug(SYSTEM_SCHEMAS, querySchema).pluralSlug;
   let tableAction = "ALTER";
-  let schemaPluralSlug = null;
   let queryTypeReadable = null;
   switch (queryType) {
     case "create": {
-      if (kind === "schemas") tableAction = "CREATE";
-      schemaPluralSlug = instructionTarget?.pluralSlug;
+      if (kind === "schemas" || kind === "indexes") tableAction = "CREATE";
       queryTypeReadable = "creating";
       break;
     }
     case "set": {
       if (kind === "schemas") tableAction = "ALTER";
-      schemaPluralSlug = instructionTarget?.pluralSlug?.being || instructionTarget?.pluralSlug;
       queryTypeReadable = "updating";
       break;
     }
     case "drop": {
-      if (kind === "schemas") tableAction = "DROP";
-      schemaPluralSlug = instructionTarget?.pluralSlug?.being || instructionTarget?.pluralSlug;
+      if (kind === "schemas" || kind === "indexes") tableAction = "DROP";
       queryTypeReadable = "deleting";
       break;
     }
   }
-  if (!schemaPluralSlug) {
-    const field = kind === "schemas" ? "pluralSlug" : "schema.pluralSlug";
+  const slug = instructionList?.slug?.being || instructionList?.slug;
+  if (!slug) {
     throw new RoninError({
-      message: `When ${queryTypeReadable} ${kind}, a \`${field}\` field must be provided in the \`${instructionName}\` instruction.`,
+      message: `When ${queryTypeReadable} ${kind}, a \`slug\` field must be provided in the \`${instructionName}\` instruction.`,
       code: "MISSING_FIELD",
-      fields: [field]
+      fields: ["slug"]
     });
   }
-  const table = convertToSnakeCase(schemaPluralSlug);
-  const fields = [...SYSTEM_FIELDS];
-  let statement = `${tableAction} TABLE "${table}"`;
+  const schemaInstruction = instructionList?.schema;
+  const schemaSlug = schemaInstruction?.slug?.being || schemaInstruction?.slug;
+  if (kind !== "schemas" && !schemaSlug) {
+    throw new RoninError({
+      message: `When ${queryTypeReadable} ${kind}, a \`schema.slug\` field must be provided in the \`${instructionName}\` instruction.`,
+      code: "MISSING_FIELD",
+      fields: ["schema.slug"]
+    });
+  }
+  const tableName = convertToSnakeCase(pluralize(kind === "schemas" ? slug : schemaSlug));
+  if (kind === "indexes") {
+    const indexName = convertToSnakeCase(slug);
+    const unique = instructionList?.unique;
+    let statement2 = `${tableAction}${unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
+    if (queryType === "create") statement2 += ` ON "${tableName}"`;
+    writeStatements.push(statement2);
+    return;
+  }
+  let statement = `${tableAction} TABLE "${tableName}"`;
   if (kind === "schemas") {
+    const fields = [...SYSTEM_FIELDS];
     if (queryType === "create") {
       const columns = fields.map(getFieldStatement).filter(Boolean);
       statement += ` (${columns.join(", ")})`;
     } else if (queryType === "set") {
-      const newSlug = queryInstructions.to?.pluralSlug;
+      const newSlug = queryInstructions.to?.slug;
       if (newSlug) {
-        const newTable = convertToSnakeCase(newSlug);
+        const newTable = convertToSnakeCase(pluralize(newSlug));
         statement += ` RENAME TO "${newTable}"`;
       }
     }
-  } else if (kind === "fields") {
-    const fieldSlug = instructionTarget?.slug?.being || instructionList?.slug;
-    if (!fieldSlug) {
-      throw new RoninError({
-        message: `When ${queryTypeReadable} fields, a \`slug\` field must be provided in the \`${instructionName}\` instruction.`,
-        code: "MISSING_FIELD",
-        fields: ["slug"]
-      });
-    }
+    writeStatements.push(statement);
+    return;
+  }
+  if (kind === "fields") {
     if (queryType === "create") {
       if (!instructionList.type) {
         throw new RoninError({
@@ -382,13 +422,29 @@ var addSchemaQueries = (queryDetails, writeStatements) => {
     } else if (queryType === "set") {
       const newSlug = queryInstructions.to?.slug;
       if (newSlug) {
-        statement += ` RENAME COLUMN "${fieldSlug}" TO "${newSlug}"`;
+        statement += ` RENAME COLUMN "${slug}" TO "${newSlug}"`;
       }
     } else if (queryType === "drop") {
-      statement += ` DROP COLUMN "${fieldSlug}"`;
+      statement += ` DROP COLUMN "${slug}"`;
     }
+    writeStatements.push(statement);
+  }
+};
+var slugToName = (slug) => {
+  const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
+  return title(name);
+};
+var VOWELS = ["a", "e", "i", "o", "u"];
+var pluralize = (word) => {
+  const lastLetter = word.slice(-1).toLowerCase();
+  const secondLastLetter = word.slice(-2, -1).toLowerCase();
+  if (lastLetter === "y" && !VOWELS.includes(secondLastLetter)) {
+    return `${word.slice(0, -1)}ies`;
+  }
+  if (lastLetter === "s" || word.slice(-2).toLowerCase() === "ch" || word.slice(-2).toLowerCase() === "sh" || word.slice(-2).toLowerCase() === "ex") {
+    return `${word}es`;
   }
-  writeStatements.push(statement);
+  return `${word}s`;
 };
 
 // src/instructions/with.ts
@@ -509,7 +565,7 @@ var composeConditions = (schemas, schema, statementValues, instructionName, valu
       if (keys.length === 1 && keys[0] === "id") {
         recordTarget = values[0];
       } else {
-        const relatedSchema = getSchemaBySlug(schemas, schemaField.target.pluralSlug);
+        const relatedSchema = getSchemaBySlug(schemas, schemaField.target.slug);
         const subQuery = {
           get: {
             [relatedSchema.slug]: {
@@ -673,7 +729,7 @@ var handleFor = (schemas, schema, statementValues, instruction, rootTable) => {
     const forFilter = schema.for?.[shortcut];
     if (!forFilter) {
       throw new RoninError({
-        message: `The provided \`for\` shortcut "${shortcut}" does not exist in schema "${getSchemaName(schema)}".`,
+        message: `The provided \`for\` shortcut "${shortcut}" does not exist in schema "${schema.name}".`,
         code: "INVALID_FOR_VALUE"
       });
     }
@@ -705,7 +761,7 @@ var handleIncluding = (schemas, statementValues, schema, instruction, rootTable)
     const includingQuery = schema.including?.[shortcut];
     if (!includingQuery) {
       throw new RoninError({
-        message: `The provided \`including\` shortcut "${shortcut}" does not exist in schema "${getSchemaName(schema)}".`,
+        message: `The provided \`including\` shortcut "${shortcut}" does not exist in schema "${schema.name}".`,
         code: "INVALID_INCLUDING_VALUE"
       });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {
@@ -28,11 +28,13 @@
   "author": "ronin",
   "license": "Apache-2.0",
   "dependencies": {
-    "@paralleldrive/cuid2": "2.2.2"
+    "@paralleldrive/cuid2": "2.2.2",
+    "title": "3.5.3"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.2",
     "@types/bun": "1.1.10",
+    "@types/title": "3.4.3",
     "tsup": "8.3.0",
     "typescript": "5.6.2",
     "zod": "3.23.8"